librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 4));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 516 {
 517         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 518         return NDR_ERR_SUCCESS;
 519 }
 520
 521 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 522 {
 523         uint32_t v;
 524         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 525         *r = v;
 526         return NDR_ERR_SUCCESS;
 527 }
 528
 529 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 530 {
 531         ndr_print_uint32(ndr, name, r);
 532         ndr->depth++;
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 561         ndr->depth--;
 562 }
 563
 564 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 565 {
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_push_align(ndr, 4));
 568                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 569                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 570                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 571                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 572                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 573                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 578                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 587                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 602                 {
 603                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 605                         {
 606                                 struct ndr_push *_ndr_driverextra_data;
 607                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 608                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 609                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 610                         }
 611                         ndr->flags = _flags_save_DATA_BLOB;
 612                 }
 613         }
 614         if (ndr_flags & NDR_BUFFERS) {
 615         }
 616         return NDR_ERR_SUCCESS;
 617 }
 618
 619 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 620 {
 621         if (ndr_flags & NDR_SCALARS) {
 622                 NDR_CHECK(ndr_pull_align(ndr, 4));
 623                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 624                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 625                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 626                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 627                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 628                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 633                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 642                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 657                 {
 658                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 660                         {
 661                                 struct ndr_pull *_ndr_driverextra_data;
 662                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 663                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 664                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 665                         }
 666                         ndr->flags = _flags_save_DATA_BLOB;
 667                 }
 668         }
 669         if (ndr_flags & NDR_BUFFERS) {
 670         }
 671         return NDR_ERR_SUCCESS;
 672 }
 673
 674 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 675 {
 676         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 677         ndr->depth++;
 678         ndr_print_string(ndr, "devicename", r->devicename);
 679         ndr_print_uint16(ndr, "specversion", r->specversion);
 680         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 681         ndr_print_uint16(ndr, "size", r->size);
 682         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 683         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 684         ndr_print_uint16(ndr, "orientation", r->orientation);
 685         ndr_print_uint16(ndr, "papersize", r->papersize);
 686         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 687         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 688         ndr_print_uint16(ndr, "scale", r->scale);
 689         ndr_print_uint16(ndr, "copies", r->copies);
 690         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 691         ndr_print_uint16(ndr, "printquality", r->printquality);
 692         ndr_print_uint16(ndr, "color", r->color);
 693         ndr_print_uint16(ndr, "duplex", r->duplex);
 694         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 695         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 696         ndr_print_uint16(ndr, "collate", r->collate);
 697         ndr_print_string(ndr, "formname", r->formname);
 698         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 699         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 700         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 701         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 702         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 703         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 704         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 705         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 706         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 707         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 708         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 709         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 710         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 711         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 712         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 713         ndr->depth--;
 714 }
 715
 716 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 717 {
 718         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 719 }
 720
 721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 722 {
 723         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 724         return NDR_ERR_SUCCESS;
 725 }
 726
 727 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 728 {
 729         uint32_t v;
 730         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 731         *r = v;
 732         return NDR_ERR_SUCCESS;
 733 }
 734
 735 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 736 {
 737         ndr_print_uint32(ndr, name, r);
 738         ndr->depth++;
 739         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 740         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 743         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 758         ndr->depth--;
 759 }
 760
 761 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 762 {
 763         if (ndr_flags & NDR_SCALARS) {
 764                 NDR_CHECK(ndr_push_align(ndr, 4));
 765                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 766                 {
 767                         uint32_t _flags_save_string = ndr->flags;
 768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 769                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 776                         ndr->flags = _flags_save_string;
 777                 }
 778                 {
 779                         uint32_t _flags_save_string = ndr->flags;
 780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 792                         }
 793                         ndr->flags = _flags_save_string;
 794                 }
 795                 {
 796                         uint32_t _flags_save_string = ndr->flags;
 797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 798                         if (r->description) {
 799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 801                         }
 802                         ndr->flags = _flags_save_string;
 803                 }
 804                 {
 805                         uint32_t _flags_save_string = ndr->flags;
 806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 807                         if (r->comment) {
 808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 810                         }
 811                         ndr->flags = _flags_save_string;
 812                 }
 813         }
 814         return NDR_ERR_SUCCESS;
 815 }
 816
 817 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 818 {
 819         uint32_t _ptr_name;
 820         TALLOC_CTX *_mem_save_name_0;
 821         uint32_t _ptr_description;
 822         TALLOC_CTX *_mem_save_description_0;
 823         uint32_t _ptr_comment;
 824         TALLOC_CTX *_mem_save_comment_0;
 825         if (ndr_flags & NDR_SCALARS) {
 826                 NDR_CHECK(ndr_pull_align(ndr, 4));
 827                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 828                 {
 829                         uint32_t _flags_save_string = ndr->flags;
 830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 832                         if (_ptr_name) {
 833                                 NDR_PULL_ALLOC(ndr, r->name);
 834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 835                         } else {
 836                                 r->name = NULL;
 837                         }
 838                         ndr->flags = _flags_save_string;
 839                 }
 840                 {
 841                         uint32_t _flags_save_string = ndr->flags;
 842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 843                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 844                         if (_ptr_description) {
 845                                 NDR_PULL_ALLOC(ndr, r->description);
 846                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 847                         } else {
 848                                 r->description = NULL;
 849                         }
 850                         ndr->flags = _flags_save_string;
 851                 }
 852                 {
 853                         uint32_t _flags_save_string = ndr->flags;
 854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 856                         if (_ptr_comment) {
 857                                 NDR_PULL_ALLOC(ndr, r->comment);
 858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 859                         } else {
 860                                 r->comment = NULL;
 861                         }
 862                         ndr->flags = _flags_save_string;
 863                 }
 864         }
 865         if (ndr_flags & NDR_BUFFERS) {
 866                 {
 867                         uint32_t _flags_save_string = ndr->flags;
 868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 869                         if (r->name) {
 870                                 uint32_t _relative_save_offset;
 871                                 _relative_save_offset = ndr->offset;
 872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 873                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 874                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 877                                 ndr->offset = _relative_save_offset;
 878                         }
 879                         ndr->flags = _flags_save_string;
 880                 }
 881                 {
 882                         uint32_t _flags_save_string = ndr->flags;
 883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 884                         if (r->description) {
 885                                 uint32_t _relative_save_offset;
 886                                 _relative_save_offset = ndr->offset;
 887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 888                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 889                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 892                                 ndr->offset = _relative_save_offset;
 893                         }
 894                         ndr->flags = _flags_save_string;
 895                 }
 896                 {
 897                         uint32_t _flags_save_string = ndr->flags;
 898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 899                         if (r->comment) {
 900                                 uint32_t _relative_save_offset;
 901                                 _relative_save_offset = ndr->offset;
 902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 903                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 904                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 907                                 ndr->offset = _relative_save_offset;
 908                         }
 909                         ndr->flags = _flags_save_string;
 910                 }
 911         }
 912         return NDR_ERR_SUCCESS;
 913 }
 914
 915 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 916 {
 917         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 918         ndr->depth++;
 919         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 920         ndr_print_ptr(ndr, "name", r->name);
 921         ndr->depth++;
 922         if (r->name) {
 923                 ndr_print_string(ndr, "name", r->name);
 924         }
 925         ndr->depth--;
 926         ndr_print_ptr(ndr, "description", r->description);
 927         ndr->depth++;
 928         if (r->description) {
 929                 ndr_print_string(ndr, "description", r->description);
 930         }
 931         ndr->depth--;
 932         ndr_print_ptr(ndr, "comment", r->comment);
 933         ndr->depth++;
 934         if (r->comment) {
 935                 ndr_print_string(ndr, "comment", r->comment);
 936         }
 937         ndr->depth--;
 938         ndr->depth--;
 939 }
 940
 941 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 942 {
 943         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 944         return NDR_ERR_SUCCESS;
 945 }
 946
 947 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 948 {
 949         uint32_t v;
 950         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 951         *r = v;
 952         return NDR_ERR_SUCCESS;
 953 }
 954
 955 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 956 {
 957         ndr_print_uint32(ndr, name, r);
 958         ndr->depth++;
 959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 968         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 975         ndr->depth--;
 976 }
 977
 978 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 979 {
 980         if (ndr_flags & NDR_SCALARS) {
 981                 NDR_CHECK(ndr_push_align(ndr, 4));
 982                 {
 983                         uint32_t _flags_save_string = ndr->flags;
 984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 985                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 986                         ndr->flags = _flags_save_string;
 987                 }
 988                 {
 989                         uint32_t _flags_save_string = ndr->flags;
 990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 991                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 992                         ndr->flags = _flags_save_string;
 993                 }
 994                 {
 995                         uint32_t _flags_save_string = ndr->flags;
 996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 997                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 998                         ndr->flags = _flags_save_string;
 999                 }
1000                 {
1001                         uint32_t _flags_save_string = ndr->flags;
1002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1003                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1004                         ndr->flags = _flags_save_string;
1005                 }
1006                 {
1007                         uint32_t _flags_save_string = ndr->flags;
1008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1009                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1010                         ndr->flags = _flags_save_string;
1011                 }
1012                 {
1013                         uint32_t _flags_save_string = ndr->flags;
1014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1015                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1016                         ndr->flags = _flags_save_string;
1017                 }
1018                 {
1019                         uint32_t _flags_save_string = ndr->flags;
1020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1022                         ndr->flags = _flags_save_string;
1023                 }
1024                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1025                 {
1026                         uint32_t _flags_save_string = ndr->flags;
1027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1028                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1029                         ndr->flags = _flags_save_string;
1030                 }
1031                 {
1032                         uint32_t _flags_save_string = ndr->flags;
1033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1034                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1035                         ndr->flags = _flags_save_string;
1036                 }
1037                 {
1038                         uint32_t _flags_save_string = ndr->flags;
1039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1040                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1041                         ndr->flags = _flags_save_string;
1042                 }
1043                 {
1044                         uint32_t _flags_save_string = ndr->flags;
1045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1046                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1047                         ndr->flags = _flags_save_string;
1048                 }
1049                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1050                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1055                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1058         }
1059         if (ndr_flags & NDR_BUFFERS) {
1060                 {
1061                         uint32_t _flags_save_string = ndr->flags;
1062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1063                         if (r->servername) {
1064                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1065                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1066                         }
1067                         ndr->flags = _flags_save_string;
1068                 }
1069                 {
1070                         uint32_t _flags_save_string = ndr->flags;
1071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1072                         if (r->printername) {
1073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1075                         }
1076                         ndr->flags = _flags_save_string;
1077                 }
1078                 {
1079                         uint32_t _flags_save_string = ndr->flags;
1080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1081                         if (r->sharename) {
1082                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1084                         }
1085                         ndr->flags = _flags_save_string;
1086                 }
1087                 {
1088                         uint32_t _flags_save_string = ndr->flags;
1089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1090                         if (r->portname) {
1091                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1093                         }
1094                         ndr->flags = _flags_save_string;
1095                 }
1096                 {
1097                         uint32_t _flags_save_string = ndr->flags;
1098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1099                         if (r->drivername) {
1100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1102                         }
1103                         ndr->flags = _flags_save_string;
1104                 }
1105                 {
1106                         uint32_t _flags_save_string = ndr->flags;
1107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1108                         if (r->comment) {
1109                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1110                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1111                         }
1112                         ndr->flags = _flags_save_string;
1113                 }
1114                 {
1115                         uint32_t _flags_save_string = ndr->flags;
1116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1117                         if (r->location) {
1118                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1119                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1120                         }
1121                         ndr->flags = _flags_save_string;
1122                 }
1123                 if (r->devmode) {
1124                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1125                         {
1126                                 struct ndr_push *_ndr_devmode;
1127                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1128                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1129                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1130                         }
1131                 }
1132                 {
1133                         uint32_t _flags_save_string = ndr->flags;
1134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1135                         if (r->sepfile) {
1136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1138                         }
1139                         ndr->flags = _flags_save_string;
1140                 }
1141                 {
1142                         uint32_t _flags_save_string = ndr->flags;
1143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1144                         if (r->printprocessor) {
1145                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1146                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1147                         }
1148                         ndr->flags = _flags_save_string;
1149                 }
1150                 {
1151                         uint32_t _flags_save_string = ndr->flags;
1152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1153                         if (r->datatype) {
1154                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1155                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1156                         }
1157                         ndr->flags = _flags_save_string;
1158                 }
1159                 {
1160                         uint32_t _flags_save_string = ndr->flags;
1161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1162                         if (r->parameters) {
1163                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1165                         }
1166                         ndr->flags = _flags_save_string;
1167                 }
1168                 if (r->secdesc) {
1169                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1170                         {
1171                                 struct ndr_push *_ndr_secdesc;
1172                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1173                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1174                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1175                         }
1176                 }
1177         }
1178         return NDR_ERR_SUCCESS;
1179 }
1180
1181 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1182 {
1183         uint32_t _ptr_servername;
1184         TALLOC_CTX *_mem_save_servername_0;
1185         uint32_t _ptr_printername;
1186         TALLOC_CTX *_mem_save_printername_0;
1187         uint32_t _ptr_sharename;
1188         TALLOC_CTX *_mem_save_sharename_0;
1189         uint32_t _ptr_portname;
1190         TALLOC_CTX *_mem_save_portname_0;
1191         uint32_t _ptr_drivername;
1192         TALLOC_CTX *_mem_save_drivername_0;
1193         uint32_t _ptr_comment;
1194         TALLOC_CTX *_mem_save_comment_0;
1195         uint32_t _ptr_location;
1196         TALLOC_CTX *_mem_save_location_0;
1197         uint32_t _ptr_devmode;
1198         TALLOC_CTX *_mem_save_devmode_0;
1199         uint32_t _ptr_sepfile;
1200         TALLOC_CTX *_mem_save_sepfile_0;
1201         uint32_t _ptr_printprocessor;
1202         TALLOC_CTX *_mem_save_printprocessor_0;
1203         uint32_t _ptr_datatype;
1204         TALLOC_CTX *_mem_save_datatype_0;
1205         uint32_t _ptr_parameters;
1206         TALLOC_CTX *_mem_save_parameters_0;
1207         uint32_t _ptr_secdesc;
1208         TALLOC_CTX *_mem_save_secdesc_0;
1209         if (ndr_flags & NDR_SCALARS) {
1210                 NDR_CHECK(ndr_pull_align(ndr, 4));
1211                 {
1212                         uint32_t _flags_save_string = ndr->flags;
1213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1215                         if (_ptr_servername) {
1216                                 NDR_PULL_ALLOC(ndr, r->servername);
1217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1218                         } else {
1219                                 r->servername = NULL;
1220                         }
1221                         ndr->flags = _flags_save_string;
1222                 }
1223                 {
1224                         uint32_t _flags_save_string = ndr->flags;
1225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1226                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1227                         if (_ptr_printername) {
1228                                 NDR_PULL_ALLOC(ndr, r->printername);
1229                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1230                         } else {
1231                                 r->printername = NULL;
1232                         }
1233                         ndr->flags = _flags_save_string;
1234                 }
1235                 {
1236                         uint32_t _flags_save_string = ndr->flags;
1237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1238                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1239                         if (_ptr_sharename) {
1240                                 NDR_PULL_ALLOC(ndr, r->sharename);
1241                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1242                         } else {
1243                                 r->sharename = NULL;
1244                         }
1245                         ndr->flags = _flags_save_string;
1246                 }
1247                 {
1248                         uint32_t _flags_save_string = ndr->flags;
1249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1250                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1251                         if (_ptr_portname) {
1252                                 NDR_PULL_ALLOC(ndr, r->portname);
1253                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1254                         } else {
1255                                 r->portname = NULL;
1256                         }
1257                         ndr->flags = _flags_save_string;
1258                 }
1259                 {
1260                         uint32_t _flags_save_string = ndr->flags;
1261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1262                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1263                         if (_ptr_drivername) {
1264                                 NDR_PULL_ALLOC(ndr, r->drivername);
1265                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1266                         } else {
1267                                 r->drivername = NULL;
1268                         }
1269                         ndr->flags = _flags_save_string;
1270                 }
1271                 {
1272                         uint32_t _flags_save_string = ndr->flags;
1273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1274                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1275                         if (_ptr_comment) {
1276                                 NDR_PULL_ALLOC(ndr, r->comment);
1277                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1278                         } else {
1279                                 r->comment = NULL;
1280                         }
1281                         ndr->flags = _flags_save_string;
1282                 }
1283                 {
1284                         uint32_t _flags_save_string = ndr->flags;
1285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1286                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1287                         if (_ptr_location) {
1288                                 NDR_PULL_ALLOC(ndr, r->location);
1289                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1290                         } else {
1291                                 r->location = NULL;
1292                         }
1293                         ndr->flags = _flags_save_string;
1294                 }
1295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1296                 if (_ptr_devmode) {
1297                         NDR_PULL_ALLOC(ndr, r->devmode);
1298                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1299                 } else {
1300                         r->devmode = NULL;
1301                 }
1302                 {
1303                         uint32_t _flags_save_string = ndr->flags;
1304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1306                         if (_ptr_sepfile) {
1307                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1309                         } else {
1310                                 r->sepfile = NULL;
1311                         }
1312                         ndr->flags = _flags_save_string;
1313                 }
1314                 {
1315                         uint32_t _flags_save_string = ndr->flags;
1316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1318                         if (_ptr_printprocessor) {
1319                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1321                         } else {
1322                                 r->printprocessor = NULL;
1323                         }
1324                         ndr->flags = _flags_save_string;
1325                 }
1326                 {
1327                         uint32_t _flags_save_string = ndr->flags;
1328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1330                         if (_ptr_datatype) {
1331                                 NDR_PULL_ALLOC(ndr, r->datatype);
1332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1333                         } else {
1334                                 r->datatype = NULL;
1335                         }
1336                         ndr->flags = _flags_save_string;
1337                 }
1338                 {
1339                         uint32_t _flags_save_string = ndr->flags;
1340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1342                         if (_ptr_parameters) {
1343                                 NDR_PULL_ALLOC(ndr, r->parameters);
1344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1345                         } else {
1346                                 r->parameters = NULL;
1347                         }
1348                         ndr->flags = _flags_save_string;
1349                 }
1350                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1351                 if (_ptr_secdesc) {
1352                         NDR_PULL_ALLOC(ndr, r->secdesc);
1353                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1354                 } else {
1355                         r->secdesc = NULL;
1356                 }
1357                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1362                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1365         }
1366         if (ndr_flags & NDR_BUFFERS) {
1367                 {
1368                         uint32_t _flags_save_string = ndr->flags;
1369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1370                         if (r->servername) {
1371                                 uint32_t _relative_save_offset;
1372                                 _relative_save_offset = ndr->offset;
1373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1374                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1375                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1376                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1378                                 ndr->offset = _relative_save_offset;
1379                         }
1380                         ndr->flags = _flags_save_string;
1381                 }
1382                 {
1383                         uint32_t _flags_save_string = ndr->flags;
1384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1385                         if (r->printername) {
1386                                 uint32_t _relative_save_offset;
1387                                 _relative_save_offset = ndr->offset;
1388                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1389                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1390                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1391                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1393                                 ndr->offset = _relative_save_offset;
1394                         }
1395                         ndr->flags = _flags_save_string;
1396                 }
1397                 {
1398                         uint32_t _flags_save_string = ndr->flags;
1399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1400                         if (r->sharename) {
1401                                 uint32_t _relative_save_offset;
1402                                 _relative_save_offset = ndr->offset;
1403                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1404                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1405                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1406                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1407                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1408                                 ndr->offset = _relative_save_offset;
1409                         }
1410                         ndr->flags = _flags_save_string;
1411                 }
1412                 {
1413                         uint32_t _flags_save_string = ndr->flags;
1414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1415                         if (r->portname) {
1416                                 uint32_t _relative_save_offset;
1417                                 _relative_save_offset = ndr->offset;
1418                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1419                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1420                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1421                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1422                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1423                                 ndr->offset = _relative_save_offset;
1424                         }
1425                         ndr->flags = _flags_save_string;
1426                 }
1427                 {
1428                         uint32_t _flags_save_string = ndr->flags;
1429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1430                         if (r->drivername) {
1431                                 uint32_t _relative_save_offset;
1432                                 _relative_save_offset = ndr->offset;
1433                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1434                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1435                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1436                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1437                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1438                                 ndr->offset = _relative_save_offset;
1439                         }
1440                         ndr->flags = _flags_save_string;
1441                 }
1442                 {
1443                         uint32_t _flags_save_string = ndr->flags;
1444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1445                         if (r->comment) {
1446                                 uint32_t _relative_save_offset;
1447                                 _relative_save_offset = ndr->offset;
1448                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1449                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1450                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1451                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1452                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1453                                 ndr->offset = _relative_save_offset;
1454                         }
1455                         ndr->flags = _flags_save_string;
1456                 }
1457                 {
1458                         uint32_t _flags_save_string = ndr->flags;
1459                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1460                         if (r->location) {
1461                                 uint32_t _relative_save_offset;
1462                                 _relative_save_offset = ndr->offset;
1463                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1464                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1465                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1466                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1467                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1468                                 ndr->offset = _relative_save_offset;
1469                         }
1470                         ndr->flags = _flags_save_string;
1471                 }
1472                 if (r->devmode) {
1473                         uint32_t _relative_save_offset;
1474                         _relative_save_offset = ndr->offset;
1475                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1476                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1477                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1478                         {
1479                                 struct ndr_pull *_ndr_devmode;
1480                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1481                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1482                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1483                         }
1484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1485                         ndr->offset = _relative_save_offset;
1486                 }
1487                 {
1488                         uint32_t _flags_save_string = ndr->flags;
1489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1490                         if (r->sepfile) {
1491                                 uint32_t _relative_save_offset;
1492                                 _relative_save_offset = ndr->offset;
1493                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1494                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1495                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1496                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1497                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1498                                 ndr->offset = _relative_save_offset;
1499                         }
1500                         ndr->flags = _flags_save_string;
1501                 }
1502                 {
1503                         uint32_t _flags_save_string = ndr->flags;
1504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1505                         if (r->printprocessor) {
1506                                 uint32_t _relative_save_offset;
1507                                 _relative_save_offset = ndr->offset;
1508                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1509                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1510                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1511                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1512                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1513                                 ndr->offset = _relative_save_offset;
1514                         }
1515                         ndr->flags = _flags_save_string;
1516                 }
1517                 {
1518                         uint32_t _flags_save_string = ndr->flags;
1519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1520                         if (r->datatype) {
1521                                 uint32_t _relative_save_offset;
1522                                 _relative_save_offset = ndr->offset;
1523                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1524                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1525                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1526                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1527                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1528                                 ndr->offset = _relative_save_offset;
1529                         }
1530                         ndr->flags = _flags_save_string;
1531                 }
1532                 {
1533                         uint32_t _flags_save_string = ndr->flags;
1534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1535                         if (r->parameters) {
1536                                 uint32_t _relative_save_offset;
1537                                 _relative_save_offset = ndr->offset;
1538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1539                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1540                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1543                                 ndr->offset = _relative_save_offset;
1544                         }
1545                         ndr->flags = _flags_save_string;
1546                 }
1547                 if (r->secdesc) {
1548                         uint32_t _relative_save_offset;
1549                         _relative_save_offset = ndr->offset;
1550                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1551                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1552                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1553                         {
1554                                 struct ndr_pull *_ndr_secdesc;
1555                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1556                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1557                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1558                         }
1559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1560                         ndr->offset = _relative_save_offset;
1561                 }
1562         }
1563         return NDR_ERR_SUCCESS;
1564 }
1565
1566 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1567 {
1568         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1569         ndr->depth++;
1570         ndr_print_ptr(ndr, "servername", r->servername);
1571         ndr->depth++;
1572         if (r->servername) {
1573                 ndr_print_string(ndr, "servername", r->servername);
1574         }
1575         ndr->depth--;
1576         ndr_print_ptr(ndr, "printername", r->printername);
1577         ndr->depth++;
1578         if (r->printername) {
1579                 ndr_print_string(ndr, "printername", r->printername);
1580         }
1581         ndr->depth--;
1582         ndr_print_ptr(ndr, "sharename", r->sharename);
1583         ndr->depth++;
1584         if (r->sharename) {
1585                 ndr_print_string(ndr, "sharename", r->sharename);
1586         }
1587         ndr->depth--;
1588         ndr_print_ptr(ndr, "portname", r->portname);
1589         ndr->depth++;
1590         if (r->portname) {
1591                 ndr_print_string(ndr, "portname", r->portname);
1592         }
1593         ndr->depth--;
1594         ndr_print_ptr(ndr, "drivername", r->drivername);
1595         ndr->depth++;
1596         if (r->drivername) {
1597                 ndr_print_string(ndr, "drivername", r->drivername);
1598         }
1599         ndr->depth--;
1600         ndr_print_ptr(ndr, "comment", r->comment);
1601         ndr->depth++;
1602         if (r->comment) {
1603                 ndr_print_string(ndr, "comment", r->comment);
1604         }
1605         ndr->depth--;
1606         ndr_print_ptr(ndr, "location", r->location);
1607         ndr->depth++;
1608         if (r->location) {
1609                 ndr_print_string(ndr, "location", r->location);
1610         }
1611         ndr->depth--;
1612         ndr_print_ptr(ndr, "devmode", r->devmode);
1613         ndr->depth++;
1614         if (r->devmode) {
1615                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1616         }
1617         ndr->depth--;
1618         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1619         ndr->depth++;
1620         if (r->sepfile) {
1621                 ndr_print_string(ndr, "sepfile", r->sepfile);
1622         }
1623         ndr->depth--;
1624         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1625         ndr->depth++;
1626         if (r->printprocessor) {
1627                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1628         }
1629         ndr->depth--;
1630         ndr_print_ptr(ndr, "datatype", r->datatype);
1631         ndr->depth++;
1632         if (r->datatype) {
1633                 ndr_print_string(ndr, "datatype", r->datatype);
1634         }
1635         ndr->depth--;
1636         ndr_print_ptr(ndr, "parameters", r->parameters);
1637         ndr->depth++;
1638         if (r->parameters) {
1639                 ndr_print_string(ndr, "parameters", r->parameters);
1640         }
1641         ndr->depth--;
1642         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1643         ndr->depth++;
1644         if (r->secdesc) {
1645                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1646         }
1647         ndr->depth--;
1648         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1649         ndr_print_uint32(ndr, "priority", r->priority);
1650         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1651         ndr_print_uint32(ndr, "starttime", r->starttime);
1652         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1653         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1654         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1655         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1656         ndr->depth--;
1657 }
1658
1659 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1660 {
1661         if (ndr_flags & NDR_SCALARS) {
1662                 NDR_CHECK(ndr_push_align(ndr, 4));
1663                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1664         }
1665         if (ndr_flags & NDR_BUFFERS) {
1666                 if (r->secdesc) {
1667                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1668                         {
1669                                 struct ndr_push *_ndr_secdesc;
1670                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1671                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1672                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1673                         }
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1680 {
1681         uint32_t _ptr_secdesc;
1682         TALLOC_CTX *_mem_save_secdesc_0;
1683         if (ndr_flags & NDR_SCALARS) {
1684                 NDR_CHECK(ndr_pull_align(ndr, 4));
1685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1686                 if (_ptr_secdesc) {
1687                         NDR_PULL_ALLOC(ndr, r->secdesc);
1688                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1689                 } else {
1690                         r->secdesc = NULL;
1691                 }
1692         }
1693         if (ndr_flags & NDR_BUFFERS) {
1694                 if (r->secdesc) {
1695                         uint32_t _relative_save_offset;
1696                         _relative_save_offset = ndr->offset;
1697                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1698                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1699                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1700                         {
1701                                 struct ndr_pull *_ndr_secdesc;
1702                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1703                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1704                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1705                         }
1706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1707                         ndr->offset = _relative_save_offset;
1708                 }
1709         }
1710         return NDR_ERR_SUCCESS;
1711 }
1712
1713 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1714 {
1715         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1716         ndr->depth++;
1717         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1718         ndr->depth++;
1719         if (r->secdesc) {
1720                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1721         }
1722         ndr->depth--;
1723         ndr->depth--;
1724 }
1725
1726 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1727 {
1728         if (ndr_flags & NDR_SCALARS) {
1729                 NDR_CHECK(ndr_push_align(ndr, 4));
1730                 {
1731                         uint32_t _flags_save_string = ndr->flags;
1732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1733                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1734                         ndr->flags = _flags_save_string;
1735                 }
1736                 {
1737                         uint32_t _flags_save_string = ndr->flags;
1738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1739                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1740                         ndr->flags = _flags_save_string;
1741                 }
1742                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1743         }
1744         if (ndr_flags & NDR_BUFFERS) {
1745                 {
1746                         uint32_t _flags_save_string = ndr->flags;
1747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1748                         if (r->printername) {
1749                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1750                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1751                         }
1752                         ndr->flags = _flags_save_string;
1753                 }
1754                 {
1755                         uint32_t _flags_save_string = ndr->flags;
1756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1757                         if (r->servername) {
1758                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1759                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1760                         }
1761                         ndr->flags = _flags_save_string;
1762                 }
1763         }
1764         return NDR_ERR_SUCCESS;
1765 }
1766
1767 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1768 {
1769         uint32_t _ptr_printername;
1770         TALLOC_CTX *_mem_save_printername_0;
1771         uint32_t _ptr_servername;
1772         TALLOC_CTX *_mem_save_servername_0;
1773         if (ndr_flags & NDR_SCALARS) {
1774                 NDR_CHECK(ndr_pull_align(ndr, 4));
1775                 {
1776                         uint32_t _flags_save_string = ndr->flags;
1777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1778                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1779                         if (_ptr_printername) {
1780                                 NDR_PULL_ALLOC(ndr, r->printername);
1781                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1782                         } else {
1783                                 r->printername = NULL;
1784                         }
1785                         ndr->flags = _flags_save_string;
1786                 }
1787                 {
1788                         uint32_t _flags_save_string = ndr->flags;
1789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1791                         if (_ptr_servername) {
1792                                 NDR_PULL_ALLOC(ndr, r->servername);
1793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1794                         } else {
1795                                 r->servername = NULL;
1796                         }
1797                         ndr->flags = _flags_save_string;
1798                 }
1799                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1800         }
1801         if (ndr_flags & NDR_BUFFERS) {
1802                 {
1803                         uint32_t _flags_save_string = ndr->flags;
1804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1805                         if (r->printername) {
1806                                 uint32_t _relative_save_offset;
1807                                 _relative_save_offset = ndr->offset;
1808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1809                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1810                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1813                                 ndr->offset = _relative_save_offset;
1814                         }
1815                         ndr->flags = _flags_save_string;
1816                 }
1817                 {
1818                         uint32_t _flags_save_string = ndr->flags;
1819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1820                         if (r->servername) {
1821                                 uint32_t _relative_save_offset;
1822                                 _relative_save_offset = ndr->offset;
1823                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1824                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1825                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1826                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1827                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1828                                 ndr->offset = _relative_save_offset;
1829                         }
1830                         ndr->flags = _flags_save_string;
1831                 }
1832         }
1833         return NDR_ERR_SUCCESS;
1834 }
1835
1836 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1837 {
1838         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1839         ndr->depth++;
1840         ndr_print_ptr(ndr, "printername", r->printername);
1841         ndr->depth++;
1842         if (r->printername) {
1843                 ndr_print_string(ndr, "printername", r->printername);
1844         }
1845         ndr->depth--;
1846         ndr_print_ptr(ndr, "servername", r->servername);
1847         ndr->depth++;
1848         if (r->servername) {
1849                 ndr_print_string(ndr, "servername", r->servername);
1850         }
1851         ndr->depth--;
1852         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1853         ndr->depth--;
1854 }
1855
1856 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1857 {
1858         if (ndr_flags & NDR_SCALARS) {
1859                 NDR_CHECK(ndr_push_align(ndr, 4));
1860                 {
1861                         uint32_t _flags_save_string = ndr->flags;
1862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1863                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1864                         ndr->flags = _flags_save_string;
1865                 }
1866                 {
1867                         uint32_t _flags_save_string = ndr->flags;
1868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1869                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1870                         ndr->flags = _flags_save_string;
1871                 }
1872                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1875         }
1876         if (ndr_flags & NDR_BUFFERS) {
1877                 {
1878                         uint32_t _flags_save_string = ndr->flags;
1879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1880                         if (r->printername) {
1881                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1882                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1883                         }
1884                         ndr->flags = _flags_save_string;
1885                 }
1886                 {
1887                         uint32_t _flags_save_string = ndr->flags;
1888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1889                         if (r->portname) {
1890                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1891                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1892                         }
1893                         ndr->flags = _flags_save_string;
1894                 }
1895         }
1896         return NDR_ERR_SUCCESS;
1897 }
1898
1899 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1900 {
1901         uint32_t _ptr_printername;
1902         TALLOC_CTX *_mem_save_printername_0;
1903         uint32_t _ptr_portname;
1904         TALLOC_CTX *_mem_save_portname_0;
1905         if (ndr_flags & NDR_SCALARS) {
1906                 NDR_CHECK(ndr_pull_align(ndr, 4));
1907                 {
1908                         uint32_t _flags_save_string = ndr->flags;
1909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1911                         if (_ptr_printername) {
1912                                 NDR_PULL_ALLOC(ndr, r->printername);
1913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1914                         } else {
1915                                 r->printername = NULL;
1916                         }
1917                         ndr->flags = _flags_save_string;
1918                 }
1919                 {
1920                         uint32_t _flags_save_string = ndr->flags;
1921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1922                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1923                         if (_ptr_portname) {
1924                                 NDR_PULL_ALLOC(ndr, r->portname);
1925                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1926                         } else {
1927                                 r->portname = NULL;
1928                         }
1929                         ndr->flags = _flags_save_string;
1930                 }
1931                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1934         }
1935         if (ndr_flags & NDR_BUFFERS) {
1936                 {
1937                         uint32_t _flags_save_string = ndr->flags;
1938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1939                         if (r->printername) {
1940                                 uint32_t _relative_save_offset;
1941                                 _relative_save_offset = ndr->offset;
1942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1943                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1944                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1947                                 ndr->offset = _relative_save_offset;
1948                         }
1949                         ndr->flags = _flags_save_string;
1950                 }
1951                 {
1952                         uint32_t _flags_save_string = ndr->flags;
1953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1954                         if (r->portname) {
1955                                 uint32_t _relative_save_offset;
1956                                 _relative_save_offset = ndr->offset;
1957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1958                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1959                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966         }
1967         return NDR_ERR_SUCCESS;
1968 }
1969
1970 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1971 {
1972         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1973         ndr->depth++;
1974         ndr_print_ptr(ndr, "printername", r->printername);
1975         ndr->depth++;
1976         if (r->printername) {
1977                 ndr_print_string(ndr, "printername", r->printername);
1978         }
1979         ndr->depth--;
1980         ndr_print_ptr(ndr, "portname", r->portname);
1981         ndr->depth++;
1982         if (r->portname) {
1983                 ndr_print_string(ndr, "portname", r->portname);
1984         }
1985         ndr->depth--;
1986         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1987         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1988         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1989         ndr->depth--;
1990 }
1991
1992 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1993 {
1994         if (ndr_flags & NDR_SCALARS) {
1995                 NDR_CHECK(ndr_push_align(ndr, 4));
1996                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1997         }
1998         if (ndr_flags & NDR_BUFFERS) {
1999         }
2000         return NDR_ERR_SUCCESS;
2001 }
2002
2003 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2004 {
2005         if (ndr_flags & NDR_SCALARS) {
2006                 NDR_CHECK(ndr_pull_align(ndr, 4));
2007                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2008         }
2009         if (ndr_flags & NDR_BUFFERS) {
2010         }
2011         return NDR_ERR_SUCCESS;
2012 }
2013
2014 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2015 {
2016         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2017         ndr->depth++;
2018         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2019         ndr->depth--;
2020 }
2021
2022 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2023 {
2024         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2025         return NDR_ERR_SUCCESS;
2026 }
2027
2028 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2029 {
2030         uint32_t v;
2031         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2032         *r = v;
2033         return NDR_ERR_SUCCESS;
2034 }
2035
2036 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2037 {
2038         ndr_print_uint32(ndr, name, r);
2039         ndr->depth++;
2040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2042         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2043         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2044         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2045         ndr->depth--;
2046 }
2047
2048 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2049 {
2050         if (ndr_flags & NDR_SCALARS) {
2051                 NDR_CHECK(ndr_push_align(ndr, 4));
2052                 {
2053                         uint32_t _flags_save_string = ndr->flags;
2054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2055                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2067                         }
2068                         ndr->flags = _flags_save_string;
2069                 }
2070         }
2071         return NDR_ERR_SUCCESS;
2072 }
2073
2074 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2075 {
2076         uint32_t _ptr_guid;
2077         TALLOC_CTX *_mem_save_guid_0;
2078         if (ndr_flags & NDR_SCALARS) {
2079                 NDR_CHECK(ndr_pull_align(ndr, 4));
2080                 {
2081                         uint32_t _flags_save_string = ndr->flags;
2082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2083                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2084                         if (_ptr_guid) {
2085                                 NDR_PULL_ALLOC(ndr, r->guid);
2086                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2087                         } else {
2088                                 r->guid = NULL;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2093         }
2094         if (ndr_flags & NDR_BUFFERS) {
2095                 {
2096                         uint32_t _flags_save_string = ndr->flags;
2097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2098                         if (r->guid) {
2099                                 uint32_t _relative_save_offset;
2100                                 _relative_save_offset = ndr->offset;
2101                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2102                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2103                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2104                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2105                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2106                                 ndr->offset = _relative_save_offset;
2107                         }
2108                         ndr->flags = _flags_save_string;
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2115 {
2116         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2117         ndr->depth++;
2118         ndr_print_ptr(ndr, "guid", r->guid);
2119         ndr->depth++;
2120         if (r->guid) {
2121                 ndr_print_string(ndr, "guid", r->guid);
2122         }
2123         ndr->depth--;
2124         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2125         ndr->depth--;
2126 }
2127
2128 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2129 {
2130         if (ndr_flags & NDR_SCALARS) {
2131                 NDR_CHECK(ndr_push_align(ndr, 4));
2132                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2133         }
2134         if (ndr_flags & NDR_BUFFERS) {
2135                 if (r->devmode) {
2136                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2137                         {
2138                                 struct ndr_push *_ndr_devmode;
2139                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2140                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2141                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2142                         }
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2149 {
2150         uint32_t _ptr_devmode;
2151         TALLOC_CTX *_mem_save_devmode_0;
2152         if (ndr_flags & NDR_SCALARS) {
2153                 NDR_CHECK(ndr_pull_align(ndr, 4));
2154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2155                 if (_ptr_devmode) {
2156                         NDR_PULL_ALLOC(ndr, r->devmode);
2157                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2158                 } else {
2159                         r->devmode = NULL;
2160                 }
2161         }
2162         if (ndr_flags & NDR_BUFFERS) {
2163                 if (r->devmode) {
2164                         uint32_t _relative_save_offset;
2165                         _relative_save_offset = ndr->offset;
2166                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2167                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2168                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2169                         {
2170                                 struct ndr_pull *_ndr_devmode;
2171                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2172                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2173                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2174                         }
2175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2176                         ndr->offset = _relative_save_offset;
2177                 }
2178         }
2179         return NDR_ERR_SUCCESS;
2180 }
2181
2182 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2183 {
2184         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2185         ndr->depth++;
2186         ndr_print_ptr(ndr, "devmode", r->devmode);
2187         ndr->depth++;
2188         if (r->devmode) {
2189                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2190         }
2191         ndr->depth--;
2192         ndr->depth--;
2193 }
2194
2195 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2196 {
2197         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2198         if (ndr_flags & NDR_SCALARS) {
2199                 int level = ndr_push_get_switch_value(ndr, r);
2200                 switch (level) {
2201                         case 0: {
2202                                 NDR_CHECK(ndr_push_align(ndr, 4));
2203                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2204                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2205                         break; }
2206
2207                         case 1: {
2208                                 NDR_CHECK(ndr_push_align(ndr, 4));
2209                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2210                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2211                         break; }
2212
2213                         case 2: {
2214                                 NDR_CHECK(ndr_push_align(ndr, 4));
2215                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2216                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2217                         break; }
2218
2219                         case 3: {
2220                                 NDR_CHECK(ndr_push_align(ndr, 4));
2221                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2222                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2223                         break; }
2224
2225                         case 4: {
2226                                 NDR_CHECK(ndr_push_align(ndr, 4));
2227                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2228                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2229                         break; }
2230
2231                         case 5: {
2232                                 NDR_CHECK(ndr_push_align(ndr, 4));
2233                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2234                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2235                         break; }
2236
2237                         case 6: {
2238                                 NDR_CHECK(ndr_push_align(ndr, 4));
2239                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2240                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2241                         break; }
2242
2243                         case 7: {
2244                                 NDR_CHECK(ndr_push_align(ndr, 4));
2245                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2246                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2247                         break; }
2248
2249                         case 8: {
2250                                 NDR_CHECK(ndr_push_align(ndr, 4));
2251                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2252                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2253                         break; }
2254
2255                         case 9: {
2256                                 NDR_CHECK(ndr_push_align(ndr, 4));
2257                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2258                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2259                         break; }
2260
2261                         default: {
2262                         break; }
2263
2264                 }
2265         }
2266         if (ndr_flags & NDR_BUFFERS) {
2267                 int level = ndr_push_get_switch_value(ndr, r);
2268                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2269                 switch (level) {
2270                         case 0:
2271                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2272                         break;
2273
2274                         case 1:
2275                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2276                         break;
2277
2278                         case 2:
2279                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2280                         break;
2281
2282                         case 3:
2283                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2284                         break;
2285
2286                         case 4:
2287                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2288                         break;
2289
2290                         case 5:
2291                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2292                         break;
2293
2294                         case 6:
2295                         break;
2296
2297                         case 7:
2298                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2299                         break;
2300
2301                         case 8:
2302                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2303                         break;
2304
2305                         case 9:
2306                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2307                         break;
2308
2309                         default:
2310                         break;
2311
2312                 }
2313         }
2314         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2315         return NDR_ERR_SUCCESS;
2316 }
2317
2318 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2319 {
2320         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2321         int level;
2322         level = ndr_pull_get_switch_value(ndr, r);
2323         if (ndr_flags & NDR_SCALARS) {
2324                 switch (level) {
2325                         case 0: {
2326                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2327                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2328                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2329                         break; }
2330
2331                         case 1: {
2332                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2333                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2334                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2335                         break; }
2336
2337                         case 2: {
2338                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2339                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2340                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2341                         break; }
2342
2343                         case 3: {
2344                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2345                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2346                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2347                         break; }
2348
2349                         case 4: {
2350                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2351                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2352                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2353                         break; }
2354
2355                         case 5: {
2356                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2357                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2358                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2359                         break; }
2360
2361                         case 6: {
2362                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2363                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2365                         break; }
2366
2367                         case 7: {
2368                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2369                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2370                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2371                         break; }
2372
2373                         case 8: {
2374                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2375                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2376                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2377                         break; }
2378
2379                         case 9: {
2380                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2381                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2382                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2383                         break; }
2384
2385                         default: {
2386                         break; }
2387
2388                 }
2389         }
2390         if (ndr_flags & NDR_BUFFERS) {
2391                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2392                 switch (level) {
2393                         case 0:
2394                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2395                         break;
2396
2397                         case 1:
2398                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2399                         break;
2400
2401                         case 2:
2402                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2403                         break;
2404
2405                         case 3:
2406                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2407                         break;
2408
2409                         case 4:
2410                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2411                         break;
2412
2413                         case 5:
2414                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2415                         break;
2416
2417                         case 6:
2418                         break;
2419
2420                         case 7:
2421                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2422                         break;
2423
2424                         case 8:
2425                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2426                         break;
2427
2428                         case 9:
2429                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2430                         break;
2431
2432                         default:
2433                         break;
2434
2435                 }
2436         }
2437         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2438         return NDR_ERR_SUCCESS;
2439 }
2440
2441 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2442 {
2443         int level;
2444         level = ndr_print_get_switch_value(ndr, r);
2445         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2446         switch (level) {
2447                 case 0:
2448                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2449                 break;
2450
2451                 case 1:
2452                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2453                 break;
2454
2455                 case 2:
2456                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2457                 break;
2458
2459                 case 3:
2460                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2461                 break;
2462
2463                 case 4:
2464                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2465                 break;
2466
2467                 case 5:
2468                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2469                 break;
2470
2471                 case 6:
2472                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2473                 break;
2474
2475                 case 7:
2476                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2477                 break;
2478
2479                 case 8:
2480                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2481                 break;
2482
2483                 case 9:
2484                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2485                 break;
2486
2487                 default:
2488                 break;
2489
2490         }
2491 }
2492
2493 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2494 {
2495         if (ndr_flags & NDR_SCALARS) {
2496                 NDR_CHECK(ndr_push_align(ndr, 4));
2497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2498                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2499         }
2500         if (ndr_flags & NDR_BUFFERS) {
2501                 if (r->devmode) {
2502                         {
2503                                 struct ndr_push *_ndr_devmode;
2504                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2505                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2506                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2507                         }
2508                 }
2509         }
2510         return NDR_ERR_SUCCESS;
2511 }
2512
2513 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2514 {
2515         uint32_t _ptr_devmode;
2516         TALLOC_CTX *_mem_save_devmode_0;
2517         if (ndr_flags & NDR_SCALARS) {
2518                 NDR_CHECK(ndr_pull_align(ndr, 4));
2519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2521                 if (_ptr_devmode) {
2522                         NDR_PULL_ALLOC(ndr, r->devmode);
2523                 } else {
2524                         r->devmode = NULL;
2525                 }
2526         }
2527         if (ndr_flags & NDR_BUFFERS) {
2528                 if (r->devmode) {
2529                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2530                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2531                         {
2532                                 struct ndr_pull *_ndr_devmode;
2533                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2534                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2535                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2536                         }
2537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2538                 }
2539         }
2540         return NDR_ERR_SUCCESS;
2541 }
2542
2543 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2544 {
2545         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2546         ndr->depth++;
2547         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2548         ndr_print_ptr(ndr, "devmode", r->devmode);
2549         ndr->depth++;
2550         if (r->devmode) {
2551                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2552         }
2553         ndr->depth--;
2554         ndr->depth--;
2555 }
2556
2557 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2558 {
2559         if (ndr_flags & NDR_SCALARS) {
2560                 NDR_CHECK(ndr_push_align(ndr, 4));
2561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2562                 {
2563                         uint32_t _flags_save_string = ndr->flags;
2564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2566                         ndr->flags = _flags_save_string;
2567                 }
2568                 {
2569                         uint32_t _flags_save_string = ndr->flags;
2570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2572                         ndr->flags = _flags_save_string;
2573                 }
2574                 {
2575                         uint32_t _flags_save_string = ndr->flags;
2576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2578                         ndr->flags = _flags_save_string;
2579                 }
2580                 {
2581                         uint32_t _flags_save_string = ndr->flags;
2582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2584                         ndr->flags = _flags_save_string;
2585                 }
2586                 {
2587                         uint32_t _flags_save_string = ndr->flags;
2588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2590                         ndr->flags = _flags_save_string;
2591                 }
2592                 {
2593                         uint32_t _flags_save_string = ndr->flags;
2594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2595                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2596                         ndr->flags = _flags_save_string;
2597                 }
2598                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2603                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2604         }
2605         if (ndr_flags & NDR_BUFFERS) {
2606                 {
2607                         uint32_t _flags_save_string = ndr->flags;
2608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2609                         if (r->printer_name) {
2610                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2611                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2612                         }
2613                         ndr->flags = _flags_save_string;
2614                 }
2615                 {
2616                         uint32_t _flags_save_string = ndr->flags;
2617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2618                         if (r->server_name) {
2619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2621                         }
2622                         ndr->flags = _flags_save_string;
2623                 }
2624                 {
2625                         uint32_t _flags_save_string = ndr->flags;
2626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2627                         if (r->user_name) {
2628                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2630                         }
2631                         ndr->flags = _flags_save_string;
2632                 }
2633                 {
2634                         uint32_t _flags_save_string = ndr->flags;
2635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2636                         if (r->document_name) {
2637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2639                         }
2640                         ndr->flags = _flags_save_string;
2641                 }
2642                 {
2643                         uint32_t _flags_save_string = ndr->flags;
2644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2645                         if (r->data_type) {
2646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2648                         }
2649                         ndr->flags = _flags_save_string;
2650                 }
2651                 {
2652                         uint32_t _flags_save_string = ndr->flags;
2653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2654                         if (r->text_status) {
2655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2657                         }
2658                         ndr->flags = _flags_save_string;
2659                 }
2660         }
2661         return NDR_ERR_SUCCESS;
2662 }
2663
2664 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2665 {
2666         uint32_t _ptr_printer_name;
2667         TALLOC_CTX *_mem_save_printer_name_0;
2668         uint32_t _ptr_server_name;
2669         TALLOC_CTX *_mem_save_server_name_0;
2670         uint32_t _ptr_user_name;
2671         TALLOC_CTX *_mem_save_user_name_0;
2672         uint32_t _ptr_document_name;
2673         TALLOC_CTX *_mem_save_document_name_0;
2674         uint32_t _ptr_data_type;
2675         TALLOC_CTX *_mem_save_data_type_0;
2676         uint32_t _ptr_text_status;
2677         TALLOC_CTX *_mem_save_text_status_0;
2678         if (ndr_flags & NDR_SCALARS) {
2679                 NDR_CHECK(ndr_pull_align(ndr, 4));
2680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2685                         if (_ptr_printer_name) {
2686                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2687                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2688                         } else {
2689                                 r->printer_name = NULL;
2690                         }
2691                         ndr->flags = _flags_save_string;
2692                 }
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2697                         if (_ptr_server_name) {
2698                                 NDR_PULL_ALLOC(ndr, r->server_name);
2699                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2700                         } else {
2701                                 r->server_name = NULL;
2702                         }
2703                         ndr->flags = _flags_save_string;
2704                 }
2705                 {
2706                         uint32_t _flags_save_string = ndr->flags;
2707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2708                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2709                         if (_ptr_user_name) {
2710                                 NDR_PULL_ALLOC(ndr, r->user_name);
2711                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2712                         } else {
2713                                 r->user_name = NULL;
2714                         }
2715                         ndr->flags = _flags_save_string;
2716                 }
2717                 {
2718                         uint32_t _flags_save_string = ndr->flags;
2719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2720                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2721                         if (_ptr_document_name) {
2722                                 NDR_PULL_ALLOC(ndr, r->document_name);
2723                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2724                         } else {
2725                                 r->document_name = NULL;
2726                         }
2727                         ndr->flags = _flags_save_string;
2728                 }
2729                 {
2730                         uint32_t _flags_save_string = ndr->flags;
2731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2732                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2733                         if (_ptr_data_type) {
2734                                 NDR_PULL_ALLOC(ndr, r->data_type);
2735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2736                         } else {
2737                                 r->data_type = NULL;
2738                         }
2739                         ndr->flags = _flags_save_string;
2740                 }
2741                 {
2742                         uint32_t _flags_save_string = ndr->flags;
2743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2745                         if (_ptr_text_status) {
2746                                 NDR_PULL_ALLOC(ndr, r->text_status);
2747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2748                         } else {
2749                                 r->text_status = NULL;
2750                         }
2751                         ndr->flags = _flags_save_string;
2752                 }
2753                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2758                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2759         }
2760         if (ndr_flags & NDR_BUFFERS) {
2761                 {
2762                         uint32_t _flags_save_string = ndr->flags;
2763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2764                         if (r->printer_name) {
2765                                 uint32_t _relative_save_offset;
2766                                 _relative_save_offset = ndr->offset;
2767                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2768                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2769                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2770                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2771                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2772                                 ndr->offset = _relative_save_offset;
2773                         }
2774                         ndr->flags = _flags_save_string;
2775                 }
2776                 {
2777                         uint32_t _flags_save_string = ndr->flags;
2778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2779                         if (r->server_name) {
2780                                 uint32_t _relative_save_offset;
2781                                 _relative_save_offset = ndr->offset;
2782                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2783                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2784                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2785                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2786                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2787                                 ndr->offset = _relative_save_offset;
2788                         }
2789                         ndr->flags = _flags_save_string;
2790                 }
2791                 {
2792                         uint32_t _flags_save_string = ndr->flags;
2793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2794                         if (r->user_name) {
2795                                 uint32_t _relative_save_offset;
2796                                 _relative_save_offset = ndr->offset;
2797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2798                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2799                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2802                                 ndr->offset = _relative_save_offset;
2803                         }
2804                         ndr->flags = _flags_save_string;
2805                 }
2806                 {
2807                         uint32_t _flags_save_string = ndr->flags;
2808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2809                         if (r->document_name) {
2810                                 uint32_t _relative_save_offset;
2811                                 _relative_save_offset = ndr->offset;
2812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2813                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2814                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2817                                 ndr->offset = _relative_save_offset;
2818                         }
2819                         ndr->flags = _flags_save_string;
2820                 }
2821                 {
2822                         uint32_t _flags_save_string = ndr->flags;
2823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2824                         if (r->data_type) {
2825                                 uint32_t _relative_save_offset;
2826                                 _relative_save_offset = ndr->offset;
2827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2828                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2829                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2832                                 ndr->offset = _relative_save_offset;
2833                         }
2834                         ndr->flags = _flags_save_string;
2835                 }
2836                 {
2837                         uint32_t _flags_save_string = ndr->flags;
2838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2839                         if (r->text_status) {
2840                                 uint32_t _relative_save_offset;
2841                                 _relative_save_offset = ndr->offset;
2842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2843                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2847                                 ndr->offset = _relative_save_offset;
2848                         }
2849                         ndr->flags = _flags_save_string;
2850                 }
2851         }
2852         return NDR_ERR_SUCCESS;
2853 }
2854
2855 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2856 {
2857         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2858         ndr->depth++;
2859         ndr_print_uint32(ndr, "job_id", r->job_id);
2860         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2861         ndr->depth++;
2862         if (r->printer_name) {
2863                 ndr_print_string(ndr, "printer_name", r->printer_name);
2864         }
2865         ndr->depth--;
2866         ndr_print_ptr(ndr, "server_name", r->server_name);
2867         ndr->depth++;
2868         if (r->server_name) {
2869                 ndr_print_string(ndr, "server_name", r->server_name);
2870         }
2871         ndr->depth--;
2872         ndr_print_ptr(ndr, "user_name", r->user_name);
2873         ndr->depth++;
2874         if (r->user_name) {
2875                 ndr_print_string(ndr, "user_name", r->user_name);
2876         }
2877         ndr->depth--;
2878         ndr_print_ptr(ndr, "document_name", r->document_name);
2879         ndr->depth++;
2880         if (r->document_name) {
2881                 ndr_print_string(ndr, "document_name", r->document_name);
2882         }
2883         ndr->depth--;
2884         ndr_print_ptr(ndr, "data_type", r->data_type);
2885         ndr->depth++;
2886         if (r->data_type) {
2887                 ndr_print_string(ndr, "data_type", r->data_type);
2888         }
2889         ndr->depth--;
2890         ndr_print_ptr(ndr, "text_status", r->text_status);
2891         ndr->depth++;
2892         if (r->text_status) {
2893                 ndr_print_string(ndr, "text_status", r->text_status);
2894         }
2895         ndr->depth--;
2896         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2897         ndr_print_uint32(ndr, "priority", r->priority);
2898         ndr_print_uint32(ndr, "position", r->position);
2899         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2900         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2901         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2902         ndr->depth--;
2903 }
2904
2905 static enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2906 {
2907         if (ndr_flags & NDR_SCALARS) {
2908                 NDR_CHECK(ndr_push_align(ndr, 4));
2909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2910                 {
2911                         uint32_t _flags_save_string = ndr->flags;
2912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2913                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2914                         ndr->flags = _flags_save_string;
2915                 }
2916                 {
2917                         uint32_t _flags_save_string = ndr->flags;
2918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2919                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2920                         ndr->flags = _flags_save_string;
2921                 }
2922                 {
2923                         uint32_t _flags_save_string = ndr->flags;
2924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2925                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2926                         ndr->flags = _flags_save_string;
2927                 }
2928                 {
2929                         uint32_t _flags_save_string = ndr->flags;
2930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2931                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2932                         ndr->flags = _flags_save_string;
2933                 }
2934                 {
2935                         uint32_t _flags_save_string = ndr->flags;
2936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2937                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2938                         ndr->flags = _flags_save_string;
2939                 }
2940                 {
2941                         uint32_t _flags_save_string = ndr->flags;
2942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2943                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2944                         ndr->flags = _flags_save_string;
2945                 }
2946                 {
2947                         uint32_t _flags_save_string = ndr->flags;
2948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2949                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
2950                         ndr->flags = _flags_save_string;
2951                 }
2952                 {
2953                         uint32_t _flags_save_string = ndr->flags;
2954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2955                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
2956                         ndr->flags = _flags_save_string;
2957                 }
2958                 {
2959                         uint32_t _flags_save_string = ndr->flags;
2960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2961                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
2962                         ndr->flags = _flags_save_string;
2963                 }
2964                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2965                 {
2966                         uint32_t _flags_save_string = ndr->flags;
2967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2968                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2969                         ndr->flags = _flags_save_string;
2970                 }
2971                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2972                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
2976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
2977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2979                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2982         }
2983         if (ndr_flags & NDR_BUFFERS) {
2984                 {
2985                         uint32_t _flags_save_string = ndr->flags;
2986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2987                         if (r->printer_name) {
2988                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2989                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2990                         }
2991                         ndr->flags = _flags_save_string;
2992                 }
2993                 {
2994                         uint32_t _flags_save_string = ndr->flags;
2995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2996                         if (r->server_name) {
2997                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2998                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2999                         }
3000                         ndr->flags = _flags_save_string;
3001                 }
3002                 {
3003                         uint32_t _flags_save_string = ndr->flags;
3004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3005                         if (r->user_name) {
3006                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3007                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3008                         }
3009                         ndr->flags = _flags_save_string;
3010                 }
3011                 {
3012                         uint32_t _flags_save_string = ndr->flags;
3013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3014                         if (r->document_name) {
3015                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3016                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3017                         }
3018                         ndr->flags = _flags_save_string;
3019                 }
3020                 {
3021                         uint32_t _flags_save_string = ndr->flags;
3022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3023                         if (r->notify_name) {
3024                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3025                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3026                         }
3027                         ndr->flags = _flags_save_string;
3028                 }
3029                 {
3030                         uint32_t _flags_save_string = ndr->flags;
3031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3032                         if (r->data_type) {
3033                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3034                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3035                         }
3036                         ndr->flags = _flags_save_string;
3037                 }
3038                 {
3039                         uint32_t _flags_save_string = ndr->flags;
3040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3041                         if (r->print_processor) {
3042                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3043                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3044                         }
3045                         ndr->flags = _flags_save_string;
3046                 }
3047                 {
3048                         uint32_t _flags_save_string = ndr->flags;
3049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3050                         if (r->parameters) {
3051                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3052                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3053                         }
3054                         ndr->flags = _flags_save_string;
3055                 }
3056                 {
3057                         uint32_t _flags_save_string = ndr->flags;
3058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3059                         if (r->driver_name) {
3060                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3061                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3062                         }
3063                         ndr->flags = _flags_save_string;
3064                 }
3065                 if (r->devmode) {
3066                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3067                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3068                 }
3069                 {
3070                         uint32_t _flags_save_string = ndr->flags;
3071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3072                         if (r->text_status) {
3073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3075                         }
3076                         ndr->flags = _flags_save_string;
3077                 }
3078                 if (r->secdesc) {
3079                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3080                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3081                 }
3082         }
3083         return NDR_ERR_SUCCESS;
3084 }
3085
3086 static enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3087 {
3088         uint32_t _ptr_printer_name;
3089         TALLOC_CTX *_mem_save_printer_name_0;
3090         uint32_t _ptr_server_name;
3091         TALLOC_CTX *_mem_save_server_name_0;
3092         uint32_t _ptr_user_name;
3093         TALLOC_CTX *_mem_save_user_name_0;
3094         uint32_t _ptr_document_name;
3095         TALLOC_CTX *_mem_save_document_name_0;
3096         uint32_t _ptr_notify_name;
3097         TALLOC_CTX *_mem_save_notify_name_0;
3098         uint32_t _ptr_data_type;
3099         TALLOC_CTX *_mem_save_data_type_0;
3100         uint32_t _ptr_print_processor;
3101         TALLOC_CTX *_mem_save_print_processor_0;
3102         uint32_t _ptr_parameters;
3103         TALLOC_CTX *_mem_save_parameters_0;
3104         uint32_t _ptr_driver_name;
3105         TALLOC_CTX *_mem_save_driver_name_0;
3106         uint32_t _ptr_devmode;
3107         TALLOC_CTX *_mem_save_devmode_0;
3108         uint32_t _ptr_text_status;
3109         TALLOC_CTX *_mem_save_text_status_0;
3110         uint32_t _ptr_secdesc;
3111         TALLOC_CTX *_mem_save_secdesc_0;
3112         if (ndr_flags & NDR_SCALARS) {
3113                 NDR_CHECK(ndr_pull_align(ndr, 4));
3114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3115                 {
3116                         uint32_t _flags_save_string = ndr->flags;
3117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3119                         if (_ptr_printer_name) {
3120                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3122                         } else {
3123                                 r->printer_name = NULL;
3124                         }
3125                         ndr->flags = _flags_save_string;
3126                 }
3127                 {
3128                         uint32_t _flags_save_string = ndr->flags;
3129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3131                         if (_ptr_server_name) {
3132                                 NDR_PULL_ALLOC(ndr, r->server_name);
3133                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3134                         } else {
3135                                 r->server_name = NULL;
3136                         }
3137                         ndr->flags = _flags_save_string;
3138                 }
3139                 {
3140                         uint32_t _flags_save_string = ndr->flags;
3141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3142                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3143                         if (_ptr_user_name) {
3144                                 NDR_PULL_ALLOC(ndr, r->user_name);
3145                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3146                         } else {
3147                                 r->user_name = NULL;
3148                         }
3149                         ndr->flags = _flags_save_string;
3150                 }
3151                 {
3152                         uint32_t _flags_save_string = ndr->flags;
3153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3155                         if (_ptr_document_name) {
3156                                 NDR_PULL_ALLOC(ndr, r->document_name);
3157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3158                         } else {
3159                                 r->document_name = NULL;
3160                         }
3161                         ndr->flags = _flags_save_string;
3162                 }
3163                 {
3164                         uint32_t _flags_save_string = ndr->flags;
3165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3166                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3167                         if (_ptr_notify_name) {
3168                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3169                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3170                         } else {
3171                                 r->notify_name = NULL;
3172                         }
3173                         ndr->flags = _flags_save_string;
3174                 }
3175                 {
3176                         uint32_t _flags_save_string = ndr->flags;
3177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3178                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3179                         if (_ptr_data_type) {
3180                                 NDR_PULL_ALLOC(ndr, r->data_type);
3181                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3182                         } else {
3183                                 r->data_type = NULL;
3184                         }
3185                         ndr->flags = _flags_save_string;
3186                 }
3187                 {
3188                         uint32_t _flags_save_string = ndr->flags;
3189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3190                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3191                         if (_ptr_print_processor) {
3192                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3193                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3194                         } else {
3195                                 r->print_processor = NULL;
3196                         }
3197                         ndr->flags = _flags_save_string;
3198                 }
3199                 {
3200                         uint32_t _flags_save_string = ndr->flags;
3201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3202                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3203                         if (_ptr_parameters) {
3204                                 NDR_PULL_ALLOC(ndr, r->parameters);
3205                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3206                         } else {
3207                                 r->parameters = NULL;
3208                         }
3209                         ndr->flags = _flags_save_string;
3210                 }
3211                 {
3212                         uint32_t _flags_save_string = ndr->flags;
3213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3215                         if (_ptr_driver_name) {
3216                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3218                         } else {
3219                                 r->driver_name = NULL;
3220                         }
3221                         ndr->flags = _flags_save_string;
3222                 }
3223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3224                 if (_ptr_devmode) {
3225                         NDR_PULL_ALLOC(ndr, r->devmode);
3226                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3227                 } else {
3228                         r->devmode = NULL;
3229                 }
3230                 {
3231                         uint32_t _flags_save_string = ndr->flags;
3232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3233                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3234                         if (_ptr_text_status) {
3235                                 NDR_PULL_ALLOC(ndr, r->text_status);
3236                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3237                         } else {
3238                                 r->text_status = NULL;
3239                         }
3240                         ndr->flags = _flags_save_string;
3241                 }
3242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3243                 if (_ptr_secdesc) {
3244                         NDR_PULL_ALLOC(ndr, r->secdesc);
3245                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3246                 } else {
3247                         r->secdesc = NULL;
3248                 }
3249                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3256                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3259         }
3260         if (ndr_flags & NDR_BUFFERS) {
3261                 {
3262                         uint32_t _flags_save_string = ndr->flags;
3263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3264                         if (r->printer_name) {
3265                                 uint32_t _relative_save_offset;
3266                                 _relative_save_offset = ndr->offset;
3267                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3268                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3269                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3270                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3271                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3272                                 ndr->offset = _relative_save_offset;
3273                         }
3274                         ndr->flags = _flags_save_string;
3275                 }
3276                 {
3277                         uint32_t _flags_save_string = ndr->flags;
3278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3279                         if (r->server_name) {
3280                                 uint32_t _relative_save_offset;
3281                                 _relative_save_offset = ndr->offset;
3282                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3283                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3284                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3285                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3286                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3287                                 ndr->offset = _relative_save_offset;
3288                         }
3289                         ndr->flags = _flags_save_string;
3290                 }
3291                 {
3292                         uint32_t _flags_save_string = ndr->flags;
3293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3294                         if (r->user_name) {
3295                                 uint32_t _relative_save_offset;
3296                                 _relative_save_offset = ndr->offset;
3297                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3298                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3299                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3300                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3301                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3302                                 ndr->offset = _relative_save_offset;
3303                         }
3304                         ndr->flags = _flags_save_string;
3305                 }
3306                 {
3307                         uint32_t _flags_save_string = ndr->flags;
3308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3309                         if (r->document_name) {
3310                                 uint32_t _relative_save_offset;
3311                                 _relative_save_offset = ndr->offset;
3312                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3313                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3314                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3315                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3316                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3317                                 ndr->offset = _relative_save_offset;
3318                         }
3319                         ndr->flags = _flags_save_string;
3320                 }
3321                 {
3322                         uint32_t _flags_save_string = ndr->flags;
3323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3324                         if (r->notify_name) {
3325                                 uint32_t _relative_save_offset;
3326                                 _relative_save_offset = ndr->offset;
3327                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3328                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3329                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3330                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3331                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3332                                 ndr->offset = _relative_save_offset;
3333                         }
3334                         ndr->flags = _flags_save_string;
3335                 }
3336                 {
3337                         uint32_t _flags_save_string = ndr->flags;
3338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3339                         if (r->data_type) {
3340                                 uint32_t _relative_save_offset;
3341                                 _relative_save_offset = ndr->offset;
3342                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3343                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3345                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3346                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3347                                 ndr->offset = _relative_save_offset;
3348                         }
3349                         ndr->flags = _flags_save_string;
3350                 }
3351                 {
3352                         uint32_t _flags_save_string = ndr->flags;
3353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3354                         if (r->print_processor) {
3355                                 uint32_t _relative_save_offset;
3356                                 _relative_save_offset = ndr->offset;
3357                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3358                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3359                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3360                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3361                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3362                                 ndr->offset = _relative_save_offset;
3363                         }
3364                         ndr->flags = _flags_save_string;
3365                 }
3366                 {
3367                         uint32_t _flags_save_string = ndr->flags;
3368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3369                         if (r->parameters) {
3370                                 uint32_t _relative_save_offset;
3371                                 _relative_save_offset = ndr->offset;
3372                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3373                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3374                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3375                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3376                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3377                                 ndr->offset = _relative_save_offset;
3378                         }
3379                         ndr->flags = _flags_save_string;
3380                 }
3381                 {
3382                         uint32_t _flags_save_string = ndr->flags;
3383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3384                         if (r->driver_name) {
3385                                 uint32_t _relative_save_offset;
3386                                 _relative_save_offset = ndr->offset;
3387                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3388                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3389                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3390                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3391                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3392                                 ndr->offset = _relative_save_offset;
3393                         }
3394                         ndr->flags = _flags_save_string;
3395                 }
3396                 if (r->devmode) {
3397                         uint32_t _relative_save_offset;
3398                         _relative_save_offset = ndr->offset;
3399                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3400                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3401                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3402                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3404                         ndr->offset = _relative_save_offset;
3405                 }
3406                 {
3407                         uint32_t _flags_save_string = ndr->flags;
3408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3409                         if (r->text_status) {
3410                                 uint32_t _relative_save_offset;
3411                                 _relative_save_offset = ndr->offset;
3412                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3413                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3414                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3415                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3416                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3417                                 ndr->offset = _relative_save_offset;
3418                         }
3419                         ndr->flags = _flags_save_string;
3420                 }
3421                 if (r->secdesc) {
3422                         uint32_t _relative_save_offset;
3423                         _relative_save_offset = ndr->offset;
3424                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3425                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3426                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3427                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3428                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3429                         ndr->offset = _relative_save_offset;
3430                 }
3431         }
3432         return NDR_ERR_SUCCESS;
3433 }
3434
3435 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3436 {
3437         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3438         ndr->depth++;
3439         ndr_print_uint32(ndr, "job_id", r->job_id);
3440         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3441         ndr->depth++;
3442         if (r->printer_name) {
3443                 ndr_print_string(ndr, "printer_name", r->printer_name);
3444         }
3445         ndr->depth--;
3446         ndr_print_ptr(ndr, "server_name", r->server_name);
3447         ndr->depth++;
3448         if (r->server_name) {
3449                 ndr_print_string(ndr, "server_name", r->server_name);
3450         }
3451         ndr->depth--;
3452         ndr_print_ptr(ndr, "user_name", r->user_name);
3453         ndr->depth++;
3454         if (r->user_name) {
3455                 ndr_print_string(ndr, "user_name", r->user_name);
3456         }
3457         ndr->depth--;
3458         ndr_print_ptr(ndr, "document_name", r->document_name);
3459         ndr->depth++;
3460         if (r->document_name) {
3461                 ndr_print_string(ndr, "document_name", r->document_name);
3462         }
3463         ndr->depth--;
3464         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3465         ndr->depth++;
3466         if (r->notify_name) {
3467                 ndr_print_string(ndr, "notify_name", r->notify_name);
3468         }
3469         ndr->depth--;
3470         ndr_print_ptr(ndr, "data_type", r->data_type);
3471         ndr->depth++;
3472         if (r->data_type) {
3473                 ndr_print_string(ndr, "data_type", r->data_type);
3474         }
3475         ndr->depth--;
3476         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3477         ndr->depth++;
3478         if (r->print_processor) {
3479                 ndr_print_string(ndr, "print_processor", r->print_processor);
3480         }
3481         ndr->depth--;
3482         ndr_print_ptr(ndr, "parameters", r->parameters);
3483         ndr->depth++;
3484         if (r->parameters) {
3485                 ndr_print_string(ndr, "parameters", r->parameters);
3486         }
3487         ndr->depth--;
3488         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3489         ndr->depth++;
3490         if (r->driver_name) {
3491                 ndr_print_string(ndr, "driver_name", r->driver_name);
3492         }
3493         ndr->depth--;
3494         ndr_print_ptr(ndr, "devmode", r->devmode);
3495         ndr->depth++;
3496         if (r->devmode) {
3497                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3498         }
3499         ndr->depth--;
3500         ndr_print_ptr(ndr, "text_status", r->text_status);
3501         ndr->depth++;
3502         if (r->text_status) {
3503                 ndr_print_string(ndr, "text_status", r->text_status);
3504         }
3505         ndr->depth--;
3506         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3507         ndr->depth++;
3508         if (r->secdesc) {
3509                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3510         }
3511         ndr->depth--;
3512         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3513         ndr_print_uint32(ndr, "priority", r->priority);
3514         ndr_print_uint32(ndr, "position", r->position);
3515         ndr_print_uint32(ndr, "start_time", r->start_time);
3516         ndr_print_uint32(ndr, "until_time", r->until_time);
3517         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3518         ndr_print_uint32(ndr, "size", r->size);
3519         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3520         ndr_print_uint32(ndr, "time", r->time);
3521         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3522         ndr->depth--;
3523 }
3524
3525 static enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3526 {
3527         if (ndr_flags & NDR_SCALARS) {
3528                 NDR_CHECK(ndr_push_align(ndr, 4));
3529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3532         }
3533         if (ndr_flags & NDR_BUFFERS) {
3534         }
3535         return NDR_ERR_SUCCESS;
3536 }
3537
3538 static enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3539 {
3540         if (ndr_flags & NDR_SCALARS) {
3541                 NDR_CHECK(ndr_pull_align(ndr, 4));
3542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3545         }
3546         if (ndr_flags & NDR_BUFFERS) {
3547         }
3548         return NDR_ERR_SUCCESS;
3549 }
3550
3551 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3552 {
3553         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3554         ndr->depth++;
3555         ndr_print_uint32(ndr, "job_id", r->job_id);
3556         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3557         ndr_print_uint32(ndr, "reserved", r->reserved);
3558         ndr->depth--;
3559 }
3560
3561 static enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3562 {
3563         if (ndr_flags & NDR_SCALARS) {
3564                 NDR_CHECK(ndr_push_align(ndr, 4));
3565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3566                 {
3567                         uint32_t _flags_save_string = ndr->flags;
3568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3570                         ndr->flags = _flags_save_string;
3571                 }
3572                 {
3573                         uint32_t _flags_save_string = ndr->flags;
3574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3575                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3576                         ndr->flags = _flags_save_string;
3577                 }
3578                 {
3579                         uint32_t _flags_save_string = ndr->flags;
3580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3581                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3582                         ndr->flags = _flags_save_string;
3583                 }
3584                 {
3585                         uint32_t _flags_save_string = ndr->flags;
3586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3588                         ndr->flags = _flags_save_string;
3589                 }
3590                 {
3591                         uint32_t _flags_save_string = ndr->flags;
3592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3593                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3594                         ndr->flags = _flags_save_string;
3595                 }
3596                 {
3597                         uint32_t _flags_save_string = ndr->flags;
3598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3600                         ndr->flags = _flags_save_string;
3601                 }
3602                 {
3603                         uint32_t _flags_save_string = ndr->flags;
3604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3606                         ndr->flags = _flags_save_string;
3607                 }
3608                 {
3609                         uint32_t _flags_save_string = ndr->flags;
3610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3611                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3612                         ndr->flags = _flags_save_string;
3613                 }
3614                 {
3615                         uint32_t _flags_save_string = ndr->flags;
3616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3617                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3618                         ndr->flags = _flags_save_string;
3619                 }
3620                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3621                 {
3622                         uint32_t _flags_save_string = ndr->flags;
3623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3624                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3625                         ndr->flags = _flags_save_string;
3626                 }
3627                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3628                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3635                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3639         }
3640         if (ndr_flags & NDR_BUFFERS) {
3641                 {
3642                         uint32_t _flags_save_string = ndr->flags;
3643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3644                         if (r->printer_name) {
3645                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3647                         }
3648                         ndr->flags = _flags_save_string;
3649                 }
3650                 {
3651                         uint32_t _flags_save_string = ndr->flags;
3652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3653                         if (r->server_name) {
3654                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3655                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3656                         }
3657                         ndr->flags = _flags_save_string;
3658                 }
3659                 {
3660                         uint32_t _flags_save_string = ndr->flags;
3661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3662                         if (r->user_name) {
3663                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3665                         }
3666                         ndr->flags = _flags_save_string;
3667                 }
3668                 {
3669                         uint32_t _flags_save_string = ndr->flags;
3670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3671                         if (r->document_name) {
3672                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3673                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3674                         }
3675                         ndr->flags = _flags_save_string;
3676                 }
3677                 {
3678                         uint32_t _flags_save_string = ndr->flags;
3679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3680                         if (r->notify_name) {
3681                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3682                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3683                         }
3684                         ndr->flags = _flags_save_string;
3685                 }
3686                 {
3687                         uint32_t _flags_save_string = ndr->flags;
3688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3689                         if (r->data_type) {
3690                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3691                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3692                         }
3693                         ndr->flags = _flags_save_string;
3694                 }
3695                 {
3696                         uint32_t _flags_save_string = ndr->flags;
3697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3698                         if (r->print_processor) {
3699                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3700                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3701                         }
3702                         ndr->flags = _flags_save_string;
3703                 }
3704                 {
3705                         uint32_t _flags_save_string = ndr->flags;
3706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3707                         if (r->parameters) {
3708                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3710                         }
3711                         ndr->flags = _flags_save_string;
3712                 }
3713                 {
3714                         uint32_t _flags_save_string = ndr->flags;
3715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3716                         if (r->driver_name) {
3717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3718                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3719                         }
3720                         ndr->flags = _flags_save_string;
3721                 }
3722                 if (r->devmode) {
3723                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3724                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3725                 }
3726                 {
3727                         uint32_t _flags_save_string = ndr->flags;
3728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3729                         if (r->text_status) {
3730                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3731                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3732                         }
3733                         ndr->flags = _flags_save_string;
3734                 }
3735                 if (r->secdesc) {
3736                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3737                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3738                 }
3739         }
3740         return NDR_ERR_SUCCESS;
3741 }
3742
3743 static enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3744 {
3745         uint32_t _ptr_printer_name;
3746         TALLOC_CTX *_mem_save_printer_name_0;
3747         uint32_t _ptr_server_name;
3748         TALLOC_CTX *_mem_save_server_name_0;
3749         uint32_t _ptr_user_name;
3750         TALLOC_CTX *_mem_save_user_name_0;
3751         uint32_t _ptr_document_name;
3752         TALLOC_CTX *_mem_save_document_name_0;
3753         uint32_t _ptr_notify_name;
3754         TALLOC_CTX *_mem_save_notify_name_0;
3755         uint32_t _ptr_data_type;
3756         TALLOC_CTX *_mem_save_data_type_0;
3757         uint32_t _ptr_print_processor;
3758         TALLOC_CTX *_mem_save_print_processor_0;
3759         uint32_t _ptr_parameters;
3760         TALLOC_CTX *_mem_save_parameters_0;
3761         uint32_t _ptr_driver_name;
3762         TALLOC_CTX *_mem_save_driver_name_0;
3763         uint32_t _ptr_devmode;
3764         TALLOC_CTX *_mem_save_devmode_0;
3765         uint32_t _ptr_text_status;
3766         TALLOC_CTX *_mem_save_text_status_0;
3767         uint32_t _ptr_secdesc;
3768         TALLOC_CTX *_mem_save_secdesc_0;
3769         if (ndr_flags & NDR_SCALARS) {
3770                 NDR_CHECK(ndr_pull_align(ndr, 4));
3771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3772                 {
3773                         uint32_t _flags_save_string = ndr->flags;
3774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3776                         if (_ptr_printer_name) {
3777                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3779                         } else {
3780                                 r->printer_name = NULL;
3781                         }
3782                         ndr->flags = _flags_save_string;
3783                 }
3784                 {
3785                         uint32_t _flags_save_string = ndr->flags;
3786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3788                         if (_ptr_server_name) {
3789                                 NDR_PULL_ALLOC(ndr, r->server_name);
3790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3791                         } else {
3792                                 r->server_name = NULL;
3793                         }
3794                         ndr->flags = _flags_save_string;
3795                 }
3796                 {
3797                         uint32_t _flags_save_string = ndr->flags;
3798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3799                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3800                         if (_ptr_user_name) {
3801                                 NDR_PULL_ALLOC(ndr, r->user_name);
3802                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3803                         } else {
3804                                 r->user_name = NULL;
3805                         }
3806                         ndr->flags = _flags_save_string;
3807                 }
3808                 {
3809                         uint32_t _flags_save_string = ndr->flags;
3810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3812                         if (_ptr_document_name) {
3813                                 NDR_PULL_ALLOC(ndr, r->document_name);
3814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3815                         } else {
3816                                 r->document_name = NULL;
3817                         }
3818                         ndr->flags = _flags_save_string;
3819                 }
3820                 {
3821                         uint32_t _flags_save_string = ndr->flags;
3822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3823                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3824                         if (_ptr_notify_name) {
3825                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3826                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3827                         } else {
3828                                 r->notify_name = NULL;
3829                         }
3830                         ndr->flags = _flags_save_string;
3831                 }
3832                 {
3833                         uint32_t _flags_save_string = ndr->flags;
3834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3835                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3836                         if (_ptr_data_type) {
3837                                 NDR_PULL_ALLOC(ndr, r->data_type);
3838                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3839                         } else {
3840                                 r->data_type = NULL;
3841                         }
3842                         ndr->flags = _flags_save_string;
3843                 }
3844                 {
3845                         uint32_t _flags_save_string = ndr->flags;
3846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3847                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3848                         if (_ptr_print_processor) {
3849                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3850                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3851                         } else {
3852                                 r->print_processor = NULL;
3853                         }
3854                         ndr->flags = _flags_save_string;
3855                 }
3856                 {
3857                         uint32_t _flags_save_string = ndr->flags;
3858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3859                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3860                         if (_ptr_parameters) {
3861                                 NDR_PULL_ALLOC(ndr, r->parameters);
3862                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3863                         } else {
3864                                 r->parameters = NULL;
3865                         }
3866                         ndr->flags = _flags_save_string;
3867                 }
3868                 {
3869                         uint32_t _flags_save_string = ndr->flags;
3870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3871                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3872                         if (_ptr_driver_name) {
3873                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3874                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3875                         } else {
3876                                 r->driver_name = NULL;
3877                         }
3878                         ndr->flags = _flags_save_string;
3879                 }
3880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3881                 if (_ptr_devmode) {
3882                         NDR_PULL_ALLOC(ndr, r->devmode);
3883                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3884                 } else {
3885                         r->devmode = NULL;
3886                 }
3887                 {
3888                         uint32_t _flags_save_string = ndr->flags;
3889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3890                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3891                         if (_ptr_text_status) {
3892                                 NDR_PULL_ALLOC(ndr, r->text_status);
3893                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3894                         } else {
3895                                 r->text_status = NULL;
3896                         }
3897                         ndr->flags = _flags_save_string;
3898                 }
3899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3900                 if (_ptr_secdesc) {
3901                         NDR_PULL_ALLOC(ndr, r->secdesc);
3902                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3903                 } else {
3904                         r->secdesc = NULL;
3905                 }
3906                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3913                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3917         }
3918         if (ndr_flags & NDR_BUFFERS) {
3919                 {
3920                         uint32_t _flags_save_string = ndr->flags;
3921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3922                         if (r->printer_name) {
3923                                 uint32_t _relative_save_offset;
3924                                 _relative_save_offset = ndr->offset;
3925                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3926                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3927                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3928                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3929                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3930                                 ndr->offset = _relative_save_offset;
3931                         }
3932                         ndr->flags = _flags_save_string;
3933                 }
3934                 {
3935                         uint32_t _flags_save_string = ndr->flags;
3936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3937                         if (r->server_name) {
3938                                 uint32_t _relative_save_offset;
3939                                 _relative_save_offset = ndr->offset;
3940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3941                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3942                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3945                                 ndr->offset = _relative_save_offset;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 {
3950                         uint32_t _flags_save_string = ndr->flags;
3951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3952                         if (r->user_name) {
3953                                 uint32_t _relative_save_offset;
3954                                 _relative_save_offset = ndr->offset;
3955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3956                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3957                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3958                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3959                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3960                                 ndr->offset = _relative_save_offset;
3961                         }
3962                         ndr->flags = _flags_save_string;
3963                 }
3964                 {
3965                         uint32_t _flags_save_string = ndr->flags;
3966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3967                         if (r->document_name) {
3968                                 uint32_t _relative_save_offset;
3969                                 _relative_save_offset = ndr->offset;
3970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3971                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3972                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3975                                 ndr->offset = _relative_save_offset;
3976                         }
3977                         ndr->flags = _flags_save_string;
3978                 }
3979                 {
3980                         uint32_t _flags_save_string = ndr->flags;
3981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3982                         if (r->notify_name) {
3983                                 uint32_t _relative_save_offset;
3984                                 _relative_save_offset = ndr->offset;
3985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3986                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3990                                 ndr->offset = _relative_save_offset;
3991                         }
3992                         ndr->flags = _flags_save_string;
3993                 }
3994                 {
3995                         uint32_t _flags_save_string = ndr->flags;
3996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3997                         if (r->data_type) {
3998                                 uint32_t _relative_save_offset;
3999                                 _relative_save_offset = ndr->offset;
4000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4001                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4002                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4005                                 ndr->offset = _relative_save_offset;
4006                         }
4007                         ndr->flags = _flags_save_string;
4008                 }
4009                 {
4010                         uint32_t _flags_save_string = ndr->flags;
4011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4012                         if (r->print_processor) {
4013                                 uint32_t _relative_save_offset;
4014                                 _relative_save_offset = ndr->offset;
4015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4016                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4017                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4020                                 ndr->offset = _relative_save_offset;
4021                         }
4022                         ndr->flags = _flags_save_string;
4023                 }
4024                 {
4025                         uint32_t _flags_save_string = ndr->flags;
4026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4027                         if (r->parameters) {
4028                                 uint32_t _relative_save_offset;
4029                                 _relative_save_offset = ndr->offset;
4030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4031                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4032                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4035                                 ndr->offset = _relative_save_offset;
4036                         }
4037                         ndr->flags = _flags_save_string;
4038                 }
4039                 {
4040                         uint32_t _flags_save_string = ndr->flags;
4041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4042                         if (r->driver_name) {
4043                                 uint32_t _relative_save_offset;
4044                                 _relative_save_offset = ndr->offset;
4045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4046                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4047                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4050                                 ndr->offset = _relative_save_offset;
4051                         }
4052                         ndr->flags = _flags_save_string;
4053                 }
4054                 if (r->devmode) {
4055                         uint32_t _relative_save_offset;
4056                         _relative_save_offset = ndr->offset;
4057                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4058                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4059                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4060                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4062                         ndr->offset = _relative_save_offset;
4063                 }
4064                 {
4065                         uint32_t _flags_save_string = ndr->flags;
4066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4067                         if (r->text_status) {
4068                                 uint32_t _relative_save_offset;
4069                                 _relative_save_offset = ndr->offset;
4070                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4071                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4072                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4073                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4074                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4075                                 ndr->offset = _relative_save_offset;
4076                         }
4077                         ndr->flags = _flags_save_string;
4078                 }
4079                 if (r->secdesc) {
4080                         uint32_t _relative_save_offset;
4081                         _relative_save_offset = ndr->offset;
4082                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4083                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4084                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4085                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4087                         ndr->offset = _relative_save_offset;
4088                 }
4089         }
4090         return NDR_ERR_SUCCESS;
4091 }
4092
4093 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4094 {
4095         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4096         ndr->depth++;
4097         ndr_print_uint32(ndr, "job_id", r->job_id);
4098         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4099         ndr->depth++;
4100         if (r->printer_name) {
4101                 ndr_print_string(ndr, "printer_name", r->printer_name);
4102         }
4103         ndr->depth--;
4104         ndr_print_ptr(ndr, "server_name", r->server_name);
4105         ndr->depth++;
4106         if (r->server_name) {
4107                 ndr_print_string(ndr, "server_name", r->server_name);
4108         }
4109         ndr->depth--;
4110         ndr_print_ptr(ndr, "user_name", r->user_name);
4111         ndr->depth++;
4112         if (r->user_name) {
4113                 ndr_print_string(ndr, "user_name", r->user_name);
4114         }
4115         ndr->depth--;
4116         ndr_print_ptr(ndr, "document_name", r->document_name);
4117         ndr->depth++;
4118         if (r->document_name) {
4119                 ndr_print_string(ndr, "document_name", r->document_name);
4120         }
4121         ndr->depth--;
4122         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4123         ndr->depth++;
4124         if (r->notify_name) {
4125                 ndr_print_string(ndr, "notify_name", r->notify_name);
4126         }
4127         ndr->depth--;
4128         ndr_print_ptr(ndr, "data_type", r->data_type);
4129         ndr->depth++;
4130         if (r->data_type) {
4131                 ndr_print_string(ndr, "data_type", r->data_type);
4132         }
4133         ndr->depth--;
4134         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4135         ndr->depth++;
4136         if (r->print_processor) {
4137                 ndr_print_string(ndr, "print_processor", r->print_processor);
4138         }
4139         ndr->depth--;
4140         ndr_print_ptr(ndr, "parameters", r->parameters);
4141         ndr->depth++;
4142         if (r->parameters) {
4143                 ndr_print_string(ndr, "parameters", r->parameters);
4144         }
4145         ndr->depth--;
4146         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4147         ndr->depth++;
4148         if (r->driver_name) {
4149                 ndr_print_string(ndr, "driver_name", r->driver_name);
4150         }
4151         ndr->depth--;
4152         ndr_print_ptr(ndr, "devmode", r->devmode);
4153         ndr->depth++;
4154         if (r->devmode) {
4155                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4156         }
4157         ndr->depth--;
4158         ndr_print_ptr(ndr, "text_status", r->text_status);
4159         ndr->depth++;
4160         if (r->text_status) {
4161                 ndr_print_string(ndr, "text_status", r->text_status);
4162         }
4163         ndr->depth--;
4164         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4165         ndr->depth++;
4166         if (r->secdesc) {
4167                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4168         }
4169         ndr->depth--;
4170         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4171         ndr_print_uint32(ndr, "priority", r->priority);
4172         ndr_print_uint32(ndr, "position", r->position);
4173         ndr_print_uint32(ndr, "start_time", r->start_time);
4174         ndr_print_uint32(ndr, "until_time", r->until_time);
4175         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4176         ndr_print_uint32(ndr, "size", r->size);
4177         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4178         ndr_print_uint32(ndr, "time", r->time);
4179         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4180         ndr_print_uint32(ndr, "size_high", r->size_high);
4181         ndr->depth--;
4182 }
4183
4184 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4185 {
4186         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4187         if (ndr_flags & NDR_SCALARS) {
4188                 int level = ndr_push_get_switch_value(ndr, r);
4189                 switch (level) {
4190                         case 1: {
4191                                 NDR_CHECK(ndr_push_align(ndr, 4));
4192                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4193                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4194                         break; }
4195
4196                         case 2: {
4197                                 NDR_CHECK(ndr_push_align(ndr, 4));
4198                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4199                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4200                         break; }
4201
4202                         case 3: {
4203                                 NDR_CHECK(ndr_push_align(ndr, 4));
4204                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4205                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4206                         break; }
4207
4208                         case 4: {
4209                                 NDR_CHECK(ndr_push_align(ndr, 4));
4210                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4211                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4212                         break; }
4213
4214                         default: {
4215                         break; }
4216
4217                 }
4218         }
4219         if (ndr_flags & NDR_BUFFERS) {
4220                 int level = ndr_push_get_switch_value(ndr, r);
4221                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4222                 switch (level) {
4223                         case 1:
4224                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4225                         break;
4226
4227                         case 2:
4228                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4229                         break;
4230
4231                         case 3:
4232                         break;
4233
4234                         case 4:
4235                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4236                         break;
4237
4238                         default:
4239                         break;
4240
4241                 }
4242         }
4243         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4244         return NDR_ERR_SUCCESS;
4245 }
4246
4247 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4248 {
4249         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4250         int level;
4251         level = ndr_pull_get_switch_value(ndr, r);
4252         if (ndr_flags & NDR_SCALARS) {
4253                 switch (level) {
4254                         case 1: {
4255                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4256                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4257                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4258                         break; }
4259
4260                         case 2: {
4261                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4262                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4263                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4264                         break; }
4265
4266                         case 3: {
4267                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4268                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4269                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4270                         break; }
4271
4272                         case 4: {
4273                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4274                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4275                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4276                         break; }
4277
4278                         default: {
4279                         break; }
4280
4281                 }
4282         }
4283         if (ndr_flags & NDR_BUFFERS) {
4284                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4285                 switch (level) {
4286                         case 1:
4287                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4288                         break;
4289
4290                         case 2:
4291                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4292                         break;
4293
4294                         case 3:
4295                         break;
4296
4297                         case 4:
4298                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4299                         break;
4300
4301                         default:
4302                         break;
4303
4304                 }
4305         }
4306         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4307         return NDR_ERR_SUCCESS;
4308 }
4309
4310 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4311 {
4312         int level;
4313         level = ndr_print_get_switch_value(ndr, r);
4314         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4315         switch (level) {
4316                 case 1:
4317                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4318                 break;
4319
4320                 case 2:
4321                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4322                 break;
4323
4324                 case 3:
4325                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4326                 break;
4327
4328                 case 4:
4329                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4330                 break;
4331
4332                 default:
4333                 break;
4334
4335         }
4336 }
4337
4338 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4339 {
4340         if (ndr_flags & NDR_SCALARS) {
4341                 NDR_CHECK(ndr_push_align(ndr, 4));
4342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4344                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4346                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4349                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4354                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4355         }
4356         if (ndr_flags & NDR_BUFFERS) {
4357                 if (r->printer_name) {
4358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4361                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4362                 }
4363                 if (r->server_name) {
4364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4367                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4368                 }
4369                 if (r->user_name) {
4370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4371                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4374                 }
4375                 if (r->document_name) {
4376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4379                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4380                 }
4381                 if (r->data_type) {
4382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4385                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4386                 }
4387                 if (r->text_status) {
4388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4391                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4392                 }
4393         }
4394         return NDR_ERR_SUCCESS;
4395 }
4396
4397 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4398 {
4399         uint32_t _ptr_printer_name;
4400         TALLOC_CTX *_mem_save_printer_name_0;
4401         uint32_t _ptr_server_name;
4402         TALLOC_CTX *_mem_save_server_name_0;
4403         uint32_t _ptr_user_name;
4404         TALLOC_CTX *_mem_save_user_name_0;
4405         uint32_t _ptr_document_name;
4406         TALLOC_CTX *_mem_save_document_name_0;
4407         uint32_t _ptr_data_type;
4408         TALLOC_CTX *_mem_save_data_type_0;
4409         uint32_t _ptr_text_status;
4410         TALLOC_CTX *_mem_save_text_status_0;
4411         if (ndr_flags & NDR_SCALARS) {
4412                 NDR_CHECK(ndr_pull_align(ndr, 4));
4413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4415                 if (_ptr_printer_name) {
4416                         NDR_PULL_ALLOC(ndr, r->printer_name);
4417                 } else {
4418                         r->printer_name = NULL;
4419                 }
4420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4421                 if (_ptr_server_name) {
4422                         NDR_PULL_ALLOC(ndr, r->server_name);
4423                 } else {
4424                         r->server_name = NULL;
4425                 }
4426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4427                 if (_ptr_user_name) {
4428                         NDR_PULL_ALLOC(ndr, r->user_name);
4429                 } else {
4430                         r->user_name = NULL;
4431                 }
4432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4433                 if (_ptr_document_name) {
4434                         NDR_PULL_ALLOC(ndr, r->document_name);
4435                 } else {
4436                         r->document_name = NULL;
4437                 }
4438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4439                 if (_ptr_data_type) {
4440                         NDR_PULL_ALLOC(ndr, r->data_type);
4441                 } else {
4442                         r->data_type = NULL;
4443                 }
4444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4445                 if (_ptr_text_status) {
4446                         NDR_PULL_ALLOC(ndr, r->text_status);
4447                 } else {
4448                         r->text_status = NULL;
4449                 }
4450                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4455                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4456         }
4457         if (ndr_flags & NDR_BUFFERS) {
4458                 if (r->printer_name) {
4459                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4460                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4463                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4464                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
4465                         }
4466                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4467                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4469                 }
4470                 if (r->server_name) {
4471                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4472                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4474                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4475                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4476                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
4477                         }
4478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4479                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4481                 }
4482                 if (r->user_name) {
4483                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4484                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4485                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4486                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4487                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4488                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4489                         }
4490                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4491                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4493                 }
4494                 if (r->document_name) {
4495                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4496                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4499                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4500                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
4501                         }
4502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4505                 }
4506                 if (r->data_type) {
4507                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4508                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4511                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4512                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
4513                         }
4514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4517                 }
4518                 if (r->text_status) {
4519                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4520                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4521                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4522                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4523                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4524                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
4525                         }
4526                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4527                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4529                 }
4530         }
4531         return NDR_ERR_SUCCESS;
4532 }
4533
4534 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4535 {
4536         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4537         ndr->depth++;
4538         ndr_print_uint32(ndr, "job_id", r->job_id);
4539         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4540         ndr->depth++;
4541         if (r->printer_name) {
4542                 ndr_print_string(ndr, "printer_name", r->printer_name);
4543         }
4544         ndr->depth--;
4545         ndr_print_ptr(ndr, "server_name", r->server_name);
4546         ndr->depth++;
4547         if (r->server_name) {
4548                 ndr_print_string(ndr, "server_name", r->server_name);
4549         }
4550         ndr->depth--;
4551         ndr_print_ptr(ndr, "user_name", r->user_name);
4552         ndr->depth++;
4553         if (r->user_name) {
4554                 ndr_print_string(ndr, "user_name", r->user_name);
4555         }
4556         ndr->depth--;
4557         ndr_print_ptr(ndr, "document_name", r->document_name);
4558         ndr->depth++;
4559         if (r->document_name) {
4560                 ndr_print_string(ndr, "document_name", r->document_name);
4561         }
4562         ndr->depth--;
4563         ndr_print_ptr(ndr, "data_type", r->data_type);
4564         ndr->depth++;
4565         if (r->data_type) {
4566                 ndr_print_string(ndr, "data_type", r->data_type);
4567         }
4568         ndr->depth--;
4569         ndr_print_ptr(ndr, "text_status", r->text_status);
4570         ndr->depth++;
4571         if (r->text_status) {
4572                 ndr_print_string(ndr, "text_status", r->text_status);
4573         }
4574         ndr->depth--;
4575         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4576         ndr_print_uint32(ndr, "priority", r->priority);
4577         ndr_print_uint32(ndr, "position", r->position);
4578         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4579         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4580         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4581         ndr->depth--;
4582 }
4583
4584 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4585 {
4586         if (ndr_flags & NDR_SCALARS) {
4587                 NDR_CHECK(ndr_push_align(ndr, 4));
4588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4589                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4591                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4592                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4594                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4595                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4596                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4597                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4601                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4608                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4611         }
4612         if (ndr_flags & NDR_BUFFERS) {
4613                 if (r->printer_name) {
4614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4617                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4618                 }
4619                 if (r->server_name) {
4620                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4621                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4623                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4624                 }
4625                 if (r->user_name) {
4626                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4627                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4628                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4629                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4630                 }
4631                 if (r->document_name) {
4632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4633                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4634                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4635                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4636                 }
4637                 if (r->notify_name) {
4638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4640                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4641                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4642                 }
4643                 if (r->data_type) {
4644                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4645                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4646                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4647                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4648                 }
4649                 if (r->print_processor) {
4650                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4651                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4652                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4653                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4654                 }
4655                 if (r->parameters) {
4656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4659                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4660                 }
4661                 if (r->driver_name) {
4662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4664                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4665                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4666                 }
4667                 if (r->text_status) {
4668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4671                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4672                 }
4673         }
4674         return NDR_ERR_SUCCESS;
4675 }
4676
4677 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4678 {
4679         uint32_t _ptr_printer_name;
4680         TALLOC_CTX *_mem_save_printer_name_0;
4681         uint32_t _ptr_server_name;
4682         TALLOC_CTX *_mem_save_server_name_0;
4683         uint32_t _ptr_user_name;
4684         TALLOC_CTX *_mem_save_user_name_0;
4685         uint32_t _ptr_document_name;
4686         TALLOC_CTX *_mem_save_document_name_0;
4687         uint32_t _ptr_notify_name;
4688         TALLOC_CTX *_mem_save_notify_name_0;
4689         uint32_t _ptr_data_type;
4690         TALLOC_CTX *_mem_save_data_type_0;
4691         uint32_t _ptr_print_processor;
4692         TALLOC_CTX *_mem_save_print_processor_0;
4693         uint32_t _ptr_parameters;
4694         TALLOC_CTX *_mem_save_parameters_0;
4695         uint32_t _ptr_driver_name;
4696         TALLOC_CTX *_mem_save_driver_name_0;
4697         uint32_t _ptr_text_status;
4698         TALLOC_CTX *_mem_save_text_status_0;
4699         if (ndr_flags & NDR_SCALARS) {
4700                 NDR_CHECK(ndr_pull_align(ndr, 4));
4701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4702                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4703                 if (_ptr_printer_name) {
4704                         NDR_PULL_ALLOC(ndr, r->printer_name);
4705                 } else {
4706                         r->printer_name = NULL;
4707                 }
4708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4709                 if (_ptr_server_name) {
4710                         NDR_PULL_ALLOC(ndr, r->server_name);
4711                 } else {
4712                         r->server_name = NULL;
4713                 }
4714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4715                 if (_ptr_user_name) {
4716                         NDR_PULL_ALLOC(ndr, r->user_name);
4717                 } else {
4718                         r->user_name = NULL;
4719                 }
4720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4721                 if (_ptr_document_name) {
4722                         NDR_PULL_ALLOC(ndr, r->document_name);
4723                 } else {
4724                         r->document_name = NULL;
4725                 }
4726                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4727                 if (_ptr_notify_name) {
4728                         NDR_PULL_ALLOC(ndr, r->notify_name);
4729                 } else {
4730                         r->notify_name = NULL;
4731                 }
4732                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4733                 if (_ptr_data_type) {
4734                         NDR_PULL_ALLOC(ndr, r->data_type);
4735                 } else {
4736                         r->data_type = NULL;
4737                 }
4738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4739                 if (_ptr_print_processor) {
4740                         NDR_PULL_ALLOC(ndr, r->print_processor);
4741                 } else {
4742                         r->print_processor = NULL;
4743                 }
4744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4745                 if (_ptr_parameters) {
4746                         NDR_PULL_ALLOC(ndr, r->parameters);
4747                 } else {
4748                         r->parameters = NULL;
4749                 }
4750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4751                 if (_ptr_driver_name) {
4752                         NDR_PULL_ALLOC(ndr, r->driver_name);
4753                 } else {
4754                         r->driver_name = NULL;
4755                 }
4756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4758                 if (_ptr_text_status) {
4759                         NDR_PULL_ALLOC(ndr, r->text_status);
4760                 } else {
4761                         r->text_status = NULL;
4762                 }
4763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4764                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4771                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4774         }
4775         if (ndr_flags & NDR_BUFFERS) {
4776                 if (r->printer_name) {
4777                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4778                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4779                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4780                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4781                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4782                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
4783                         }
4784                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4785                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4787                 }
4788                 if (r->server_name) {
4789                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4790                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4793                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4794                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
4795                         }
4796                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4797                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4799                 }
4800                 if (r->user_name) {
4801                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4802                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4805                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4806                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4807                         }
4808                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4811                 }
4812                 if (r->document_name) {
4813                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4814                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4816                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4817                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4818                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
4819                         }
4820                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4821                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4823                 }
4824                 if (r->notify_name) {
4825                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4826                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4827                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4828                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4829                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4830                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
4831                         }
4832                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4833                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4835                 }
4836                 if (r->data_type) {
4837                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4838                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4839                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4840                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4841                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4842                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
4843                         }
4844                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4845                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4847                 }
4848                 if (r->print_processor) {
4849                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4850                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4853                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4854                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
4855                         }
4856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4857                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4859                 }
4860                 if (r->parameters) {
4861                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4862                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4865                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4866                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
4867                         }
4868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4871                 }
4872                 if (r->driver_name) {
4873                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4874                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4877                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4878                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4879                         }
4880                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4881                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4883                 }
4884                 if (r->text_status) {
4885                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4886                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4887                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4888                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4889                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4890                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
4891                         }
4892                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4893                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4895                 }
4896         }
4897         return NDR_ERR_SUCCESS;
4898 }
4899
4900 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4901 {
4902         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4903         ndr->depth++;
4904         ndr_print_uint32(ndr, "job_id", r->job_id);
4905         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4906         ndr->depth++;
4907         if (r->printer_name) {
4908                 ndr_print_string(ndr, "printer_name", r->printer_name);
4909         }
4910         ndr->depth--;
4911         ndr_print_ptr(ndr, "server_name", r->server_name);
4912         ndr->depth++;
4913         if (r->server_name) {
4914                 ndr_print_string(ndr, "server_name", r->server_name);
4915         }
4916         ndr->depth--;
4917         ndr_print_ptr(ndr, "user_name", r->user_name);
4918         ndr->depth++;
4919         if (r->user_name) {
4920                 ndr_print_string(ndr, "user_name", r->user_name);
4921         }
4922         ndr->depth--;
4923         ndr_print_ptr(ndr, "document_name", r->document_name);
4924         ndr->depth++;
4925         if (r->document_name) {
4926                 ndr_print_string(ndr, "document_name", r->document_name);
4927         }
4928         ndr->depth--;
4929         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4930         ndr->depth++;
4931         if (r->notify_name) {
4932                 ndr_print_string(ndr, "notify_name", r->notify_name);
4933         }
4934         ndr->depth--;
4935         ndr_print_ptr(ndr, "data_type", r->data_type);
4936         ndr->depth++;
4937         if (r->data_type) {
4938                 ndr_print_string(ndr, "data_type", r->data_type);
4939         }
4940         ndr->depth--;
4941         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4942         ndr->depth++;
4943         if (r->print_processor) {
4944                 ndr_print_string(ndr, "print_processor", r->print_processor);
4945         }
4946         ndr->depth--;
4947         ndr_print_ptr(ndr, "parameters", r->parameters);
4948         ndr->depth++;
4949         if (r->parameters) {
4950                 ndr_print_string(ndr, "parameters", r->parameters);
4951         }
4952         ndr->depth--;
4953         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4954         ndr->depth++;
4955         if (r->driver_name) {
4956                 ndr_print_string(ndr, "driver_name", r->driver_name);
4957         }
4958         ndr->depth--;
4959         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
4960         ndr_print_ptr(ndr, "text_status", r->text_status);
4961         ndr->depth++;
4962         if (r->text_status) {
4963                 ndr_print_string(ndr, "text_status", r->text_status);
4964         }
4965         ndr->depth--;
4966         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
4967         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4968         ndr_print_uint32(ndr, "priority", r->priority);
4969         ndr_print_uint32(ndr, "position", r->position);
4970         ndr_print_uint32(ndr, "start_time", r->start_time);
4971         ndr_print_uint32(ndr, "until_time", r->until_time);
4972         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4973         ndr_print_uint32(ndr, "size", r->size);
4974         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4975         ndr_print_uint32(ndr, "time", r->time);
4976         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4977         ndr->depth--;
4978 }
4979
4980 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
4981 {
4982         if (ndr_flags & NDR_SCALARS) {
4983                 NDR_CHECK(ndr_push_align(ndr, 4));
4984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4991                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4997                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5002                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5004                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5008         }
5009         if (ndr_flags & NDR_BUFFERS) {
5010                 if (r->printer_name) {
5011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5014                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5015                 }
5016                 if (r->server_name) {
5017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5020                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5021                 }
5022                 if (r->user_name) {
5023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5026                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5027                 }
5028                 if (r->document_name) {
5029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5032                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5033                 }
5034                 if (r->notify_name) {
5035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5038                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5039                 }
5040                 if (r->data_type) {
5041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5044                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5045                 }
5046                 if (r->print_processor) {
5047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5051                 }
5052                 if (r->parameters) {
5053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5057                 }
5058                 if (r->driver_name) {
5059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5063                 }
5064                 if (r->text_status) {
5065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5069                 }
5070         }
5071         return NDR_ERR_SUCCESS;
5072 }
5073
5074 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5075 {
5076         uint32_t _ptr_printer_name;
5077         TALLOC_CTX *_mem_save_printer_name_0;
5078         uint32_t _ptr_server_name;
5079         TALLOC_CTX *_mem_save_server_name_0;
5080         uint32_t _ptr_user_name;
5081         TALLOC_CTX *_mem_save_user_name_0;
5082         uint32_t _ptr_document_name;
5083         TALLOC_CTX *_mem_save_document_name_0;
5084         uint32_t _ptr_notify_name;
5085         TALLOC_CTX *_mem_save_notify_name_0;
5086         uint32_t _ptr_data_type;
5087         TALLOC_CTX *_mem_save_data_type_0;
5088         uint32_t _ptr_print_processor;
5089         TALLOC_CTX *_mem_save_print_processor_0;
5090         uint32_t _ptr_parameters;
5091         TALLOC_CTX *_mem_save_parameters_0;
5092         uint32_t _ptr_driver_name;
5093         TALLOC_CTX *_mem_save_driver_name_0;
5094         uint32_t _ptr_text_status;
5095         TALLOC_CTX *_mem_save_text_status_0;
5096         if (ndr_flags & NDR_SCALARS) {
5097                 NDR_CHECK(ndr_pull_align(ndr, 4));
5098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5100                 if (_ptr_printer_name) {
5101                         NDR_PULL_ALLOC(ndr, r->printer_name);
5102                 } else {
5103                         r->printer_name = NULL;
5104                 }
5105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5106                 if (_ptr_server_name) {
5107                         NDR_PULL_ALLOC(ndr, r->server_name);
5108                 } else {
5109                         r->server_name = NULL;
5110                 }
5111                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5112                 if (_ptr_user_name) {
5113                         NDR_PULL_ALLOC(ndr, r->user_name);
5114                 } else {
5115                         r->user_name = NULL;
5116                 }
5117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5118                 if (_ptr_document_name) {
5119                         NDR_PULL_ALLOC(ndr, r->document_name);
5120                 } else {
5121                         r->document_name = NULL;
5122                 }
5123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5124                 if (_ptr_notify_name) {
5125                         NDR_PULL_ALLOC(ndr, r->notify_name);
5126                 } else {
5127                         r->notify_name = NULL;
5128                 }
5129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5130                 if (_ptr_data_type) {
5131                         NDR_PULL_ALLOC(ndr, r->data_type);
5132                 } else {
5133                         r->data_type = NULL;
5134                 }
5135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5136                 if (_ptr_print_processor) {
5137                         NDR_PULL_ALLOC(ndr, r->print_processor);
5138                 } else {
5139                         r->print_processor = NULL;
5140                 }
5141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5142                 if (_ptr_parameters) {
5143                         NDR_PULL_ALLOC(ndr, r->parameters);
5144                 } else {
5145                         r->parameters = NULL;
5146                 }
5147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5148                 if (_ptr_driver_name) {
5149                         NDR_PULL_ALLOC(ndr, r->driver_name);
5150                 } else {
5151                         r->driver_name = NULL;
5152                 }
5153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5155                 if (_ptr_text_status) {
5156                         NDR_PULL_ALLOC(ndr, r->text_status);
5157                 } else {
5158                         r->text_status = NULL;
5159                 }
5160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5161                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5168                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5172         }
5173         if (ndr_flags & NDR_BUFFERS) {
5174                 if (r->printer_name) {
5175                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5176                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5178                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5179                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5180                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5181                         }
5182                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5183                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5185                 }
5186                 if (r->server_name) {
5187                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5188                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5191                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5192                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5193                         }
5194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5197                 }
5198                 if (r->user_name) {
5199                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5200                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5202                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5203                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5204                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5205                         }
5206                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5209                 }
5210                 if (r->document_name) {
5211                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5212                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5213                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5214                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5215                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5216                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5217                         }
5218                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5221                 }
5222                 if (r->notify_name) {
5223                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5224                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5225                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5226                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5227                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5228                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5229                         }
5230                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5231                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5232                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5233                 }
5234                 if (r->data_type) {
5235                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5236                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5237                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5238                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5239                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5240                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5241                         }
5242                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5243                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5244                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5245                 }
5246                 if (r->print_processor) {
5247                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5248                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5249                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5250                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5251                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5252                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5253                         }
5254                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5255                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5257                 }
5258                 if (r->parameters) {
5259                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5260                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5261                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5262                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5263                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5264                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5265                         }
5266                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5267                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5268                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5269                 }
5270                 if (r->driver_name) {
5271                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5272                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5273                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5274                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5275                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5276                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5277                         }
5278                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5279                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5281                 }
5282                 if (r->text_status) {
5283                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5284                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5286                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5287                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5288                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5289                         }
5290                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5291                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5293                 }
5294         }
5295         return NDR_ERR_SUCCESS;
5296 }
5297
5298 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5299 {
5300         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5301         ndr->depth++;
5302         ndr_print_uint32(ndr, "job_id", r->job_id);
5303         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5304         ndr->depth++;
5305         if (r->printer_name) {
5306                 ndr_print_string(ndr, "printer_name", r->printer_name);
5307         }
5308         ndr->depth--;
5309         ndr_print_ptr(ndr, "server_name", r->server_name);
5310         ndr->depth++;
5311         if (r->server_name) {
5312                 ndr_print_string(ndr, "server_name", r->server_name);
5313         }
5314         ndr->depth--;
5315         ndr_print_ptr(ndr, "user_name", r->user_name);
5316         ndr->depth++;
5317         if (r->user_name) {
5318                 ndr_print_string(ndr, "user_name", r->user_name);
5319         }
5320         ndr->depth--;
5321         ndr_print_ptr(ndr, "document_name", r->document_name);
5322         ndr->depth++;
5323         if (r->document_name) {
5324                 ndr_print_string(ndr, "document_name", r->document_name);
5325         }
5326         ndr->depth--;
5327         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5328         ndr->depth++;
5329         if (r->notify_name) {
5330                 ndr_print_string(ndr, "notify_name", r->notify_name);
5331         }
5332         ndr->depth--;
5333         ndr_print_ptr(ndr, "data_type", r->data_type);
5334         ndr->depth++;
5335         if (r->data_type) {
5336                 ndr_print_string(ndr, "data_type", r->data_type);
5337         }
5338         ndr->depth--;
5339         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5340         ndr->depth++;
5341         if (r->print_processor) {
5342                 ndr_print_string(ndr, "print_processor", r->print_processor);
5343         }
5344         ndr->depth--;
5345         ndr_print_ptr(ndr, "parameters", r->parameters);
5346         ndr->depth++;
5347         if (r->parameters) {
5348                 ndr_print_string(ndr, "parameters", r->parameters);
5349         }
5350         ndr->depth--;
5351         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5352         ndr->depth++;
5353         if (r->driver_name) {
5354                 ndr_print_string(ndr, "driver_name", r->driver_name);
5355         }
5356         ndr->depth--;
5357         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5358         ndr_print_ptr(ndr, "text_status", r->text_status);
5359         ndr->depth++;
5360         if (r->text_status) {
5361                 ndr_print_string(ndr, "text_status", r->text_status);
5362         }
5363         ndr->depth--;
5364         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5365         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5366         ndr_print_uint32(ndr, "priority", r->priority);
5367         ndr_print_uint32(ndr, "position", r->position);
5368         ndr_print_uint32(ndr, "start_time", r->start_time);
5369         ndr_print_uint32(ndr, "until_time", r->until_time);
5370         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5371         ndr_print_uint32(ndr, "size", r->size);
5372         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5373         ndr_print_uint32(ndr, "time", r->time);
5374         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5375         ndr_print_uint32(ndr, "size_high", r->size_high);
5376         ndr->depth--;
5377 }
5378
5379 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5380 {
5381         if (ndr_flags & NDR_SCALARS) {
5382                 int level = ndr_push_get_switch_value(ndr, r);
5383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5384                 switch (level) {
5385                         case 1: {
5386                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5387                         break; }
5388
5389                         case 2: {
5390                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5391                         break; }
5392
5393                         case 3: {
5394                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5395                         break; }
5396
5397                         case 4: {
5398                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5399                         break; }
5400
5401                         default: {
5402                         break; }
5403
5404                 }
5405         }
5406         if (ndr_flags & NDR_BUFFERS) {
5407                 int level = ndr_push_get_switch_value(ndr, r);
5408                 switch (level) {
5409                         case 1:
5410                                 if (r->info1) {
5411                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5412                                 }
5413                         break;
5414
5415                         case 2:
5416                                 if (r->info2) {
5417                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5418                                 }
5419                         break;
5420
5421                         case 3:
5422                                 if (r->info3) {
5423                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5424                                 }
5425                         break;
5426
5427                         case 4:
5428                                 if (r->info4) {
5429                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5430                                 }
5431                         break;
5432
5433                         default:
5434                         break;
5435
5436                 }
5437         }
5438         return NDR_ERR_SUCCESS;
5439 }
5440
5441 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5442 {
5443         int level;
5444         uint32_t _level;
5445         TALLOC_CTX *_mem_save_info1_0;
5446         TALLOC_CTX *_mem_save_info2_0;
5447         TALLOC_CTX *_mem_save_info3_0;
5448         TALLOC_CTX *_mem_save_info4_0;
5449         level = ndr_pull_get_switch_value(ndr, r);
5450         if (ndr_flags & NDR_SCALARS) {
5451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5452                 if (_level != level) {
5453                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5454                 }
5455                 switch (level) {
5456                         case 1: {
5457                                 uint32_t _ptr_info1;
5458                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5459                                 if (_ptr_info1) {
5460                                         NDR_PULL_ALLOC(ndr, r->info1);
5461                                 } else {
5462                                         r->info1 = NULL;
5463                                 }
5464                         break; }
5465
5466                         case 2: {
5467                                 uint32_t _ptr_info2;
5468                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5469                                 if (_ptr_info2) {
5470                                         NDR_PULL_ALLOC(ndr, r->info2);
5471                                 } else {
5472                                         r->info2 = NULL;
5473                                 }
5474                         break; }
5475
5476                         case 3: {
5477                                 uint32_t _ptr_info3;
5478                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5479                                 if (_ptr_info3) {
5480                                         NDR_PULL_ALLOC(ndr, r->info3);
5481                                 } else {
5482                                         r->info3 = NULL;
5483                                 }
5484                         break; }
5485
5486                         case 4: {
5487                                 uint32_t _ptr_info4;
5488                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5489                                 if (_ptr_info4) {
5490                                         NDR_PULL_ALLOC(ndr, r->info4);
5491                                 } else {
5492                                         r->info4 = NULL;
5493                                 }
5494                         break; }
5495
5496                         default: {
5497                         break; }
5498
5499                 }
5500         }
5501         if (ndr_flags & NDR_BUFFERS) {
5502                 switch (level) {
5503                         case 1:
5504                                 if (r->info1) {
5505                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5506                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5507                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5508                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5509                                 }
5510                         break;
5511
5512                         case 2:
5513                                 if (r->info2) {
5514                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5515                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5516                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5517                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5518                                 }
5519                         break;
5520
5521                         case 3:
5522                                 if (r->info3) {
5523                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5524                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5525                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5526                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5527                                 }
5528                         break;
5529
5530                         case 4:
5531                                 if (r->info4) {
5532                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5533                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5534                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5535                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5536                                 }
5537                         break;
5538
5539                         default:
5540                         break;
5541
5542                 }
5543         }
5544         return NDR_ERR_SUCCESS;
5545 }
5546
5547 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5548 {
5549         int level;
5550         level = ndr_print_get_switch_value(ndr, r);
5551         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5552         switch (level) {
5553                 case 1:
5554                         ndr_print_ptr(ndr, "info1", r->info1);
5555                         ndr->depth++;
5556                         if (r->info1) {
5557                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5558                         }
5559                         ndr->depth--;
5560                 break;
5561
5562                 case 2:
5563                         ndr_print_ptr(ndr, "info2", r->info2);
5564                         ndr->depth++;
5565                         if (r->info2) {
5566                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5567                         }
5568                         ndr->depth--;
5569                 break;
5570
5571                 case 3:
5572                         ndr_print_ptr(ndr, "info3", r->info3);
5573                         ndr->depth++;
5574                         if (r->info3) {
5575                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5576                         }
5577                         ndr->depth--;
5578                 break;
5579
5580                 case 4:
5581                         ndr_print_ptr(ndr, "info4", r->info4);
5582                         ndr->depth++;
5583                         if (r->info4) {
5584                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5585                         }
5586                         ndr->depth--;
5587                 break;
5588
5589                 default:
5590                 break;
5591
5592         }
5593 }
5594
5595 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5596 {
5597         if (ndr_flags & NDR_SCALARS) {
5598                 NDR_CHECK(ndr_push_align(ndr, 4));
5599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5600                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5601                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5602         }
5603         if (ndr_flags & NDR_BUFFERS) {
5604                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5605         }
5606         return NDR_ERR_SUCCESS;
5607 }
5608
5609 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5610 {
5611         if (ndr_flags & NDR_SCALARS) {
5612                 NDR_CHECK(ndr_pull_align(ndr, 4));
5613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5614                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5615                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5616         }
5617         if (ndr_flags & NDR_BUFFERS) {
5618                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5619         }
5620         return NDR_ERR_SUCCESS;
5621 }
5622
5623 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5624 {
5625         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5626         ndr->depth++;
5627         ndr_print_uint32(ndr, "level", r->level);
5628         ndr_print_set_switch_value(ndr, &r->info, r->level);
5629         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5630         ndr->depth--;
5631 }
5632
5633 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5634 {
5635         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5636         return NDR_ERR_SUCCESS;
5637 }
5638
5639 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5640 {
5641         uint32_t v;
5642         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5643         *r = v;
5644         return NDR_ERR_SUCCESS;
5645 }
5646
5647 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5648 {
5649         const char *val = NULL;
5650
5651         switch (r) {
5652                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5653                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5654                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5655                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5656                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5657                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5658                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5659                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5660                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5661         }
5662         ndr_print_enum(ndr, name, "ENUM", val, r);
5663 }
5664
5665 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5666 {
5667         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5668         return NDR_ERR_SUCCESS;
5669 }
5670
5671 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5672 {
5673         uint32_t v;
5674         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5675         *r = v;
5676         return NDR_ERR_SUCCESS;
5677 }
5678
5679 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5680 {
5681         const char *val = NULL;
5682
5683         switch (r) {
5684                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5685                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5686                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5687                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5688                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5689         }
5690         ndr_print_enum(ndr, name, "ENUM", val, r);
5691 }
5692
5693 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5694 {
5695         if (ndr_flags & NDR_SCALARS) {
5696                 NDR_CHECK(ndr_push_align(ndr, 4));
5697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5702                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5714                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5721                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5722                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5726         }
5727         if (ndr_flags & NDR_BUFFERS) {
5728                 if (r->servername) {
5729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5732                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5733                 }
5734                 if (r->printername) {
5735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5739                 }
5740         }
5741         return NDR_ERR_SUCCESS;
5742 }
5743
5744 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5745 {
5746         uint32_t _ptr_servername;
5747         TALLOC_CTX *_mem_save_servername_0;
5748         uint32_t _ptr_printername;
5749         TALLOC_CTX *_mem_save_printername_0;
5750         if (ndr_flags & NDR_SCALARS) {
5751                 NDR_CHECK(ndr_pull_align(ndr, 4));
5752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5753                 if (_ptr_servername) {
5754                         NDR_PULL_ALLOC(ndr, r->servername);
5755                 } else {
5756                         r->servername = NULL;
5757                 }
5758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5759                 if (_ptr_printername) {
5760                         NDR_PULL_ALLOC(ndr, r->printername);
5761                 } else {
5762                         r->printername = NULL;
5763                 }
5764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5767                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5779                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5786                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5787                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5791         }
5792         if (ndr_flags & NDR_BUFFERS) {
5793                 if (r->servername) {
5794                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5795                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5796                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5797                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5798                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5799                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
5800                         }
5801                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5802                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5804                 }
5805                 if (r->printername) {
5806                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5807                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5809                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5810                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5811                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
5812                         }
5813                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5814                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5816                 }
5817         }
5818         return NDR_ERR_SUCCESS;
5819 }
5820
5821 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5822 {
5823         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5824         ndr->depth++;
5825         ndr_print_ptr(ndr, "servername", r->servername);
5826         ndr->depth++;
5827         if (r->servername) {
5828                 ndr_print_string(ndr, "servername", r->servername);
5829         }
5830         ndr->depth--;
5831         ndr_print_ptr(ndr, "printername", r->printername);
5832         ndr->depth++;
5833         if (r->printername) {
5834                 ndr_print_string(ndr, "printername", r->printername);
5835         }
5836         ndr->depth--;
5837         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5838         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5839         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5840         ndr_print_spoolss_Time(ndr, "time", &r->time);
5841         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5842         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5843         ndr_print_uint32(ndr, "version", r->version);
5844         ndr_print_uint32(ndr, "free_build", r->free_build);
5845         ndr_print_uint32(ndr, "spooling", r->spooling);
5846         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5847         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5848         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5849         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5850         ndr_print_uint32(ndr, "job_error", r->job_error);
5851         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5852         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5853         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5854         ndr_print_uint32(ndr, "change_id", r->change_id);
5855         ndr_print_WERROR(ndr, "last_error", r->last_error);
5856         ndr_print_uint32(ndr, "status", r->status);
5857         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5858         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5859         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5860         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5861         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5862         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5863         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5864         ndr->depth--;
5865 }
5866
5867 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5868 {
5869         if (ndr_flags & NDR_SCALARS) {
5870                 NDR_CHECK(ndr_push_align(ndr, 4));
5871                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5872                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5873                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5875         }
5876         if (ndr_flags & NDR_BUFFERS) {
5877                 if (r->name) {
5878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5881                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5882                 }
5883                 if (r->description) {
5884                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5885                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5886                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5887                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5888                 }
5889                 if (r->comment) {
5890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5891                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5893                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5894                 }
5895         }
5896         return NDR_ERR_SUCCESS;
5897 }
5898
5899 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5900 {
5901         uint32_t _ptr_name;
5902         TALLOC_CTX *_mem_save_name_0;
5903         uint32_t _ptr_description;
5904         TALLOC_CTX *_mem_save_description_0;
5905         uint32_t _ptr_comment;
5906         TALLOC_CTX *_mem_save_comment_0;
5907         if (ndr_flags & NDR_SCALARS) {
5908                 NDR_CHECK(ndr_pull_align(ndr, 4));
5909                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
5910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
5911                 if (_ptr_name) {
5912                         NDR_PULL_ALLOC(ndr, r->name);
5913                 } else {
5914                         r->name = NULL;
5915                 }
5916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
5917                 if (_ptr_description) {
5918                         NDR_PULL_ALLOC(ndr, r->description);
5919                 } else {
5920                         r->description = NULL;
5921                 }
5922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
5923                 if (_ptr_comment) {
5924                         NDR_PULL_ALLOC(ndr, r->comment);
5925                 } else {
5926                         r->comment = NULL;
5927                 }
5928         }
5929         if (ndr_flags & NDR_BUFFERS) {
5930                 if (r->name) {
5931                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5932                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
5933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
5934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
5935                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
5936                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
5937                         }
5938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
5939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
5940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
5941                 }
5942                 if (r->description) {
5943                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
5944                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
5945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
5946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
5947                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
5948                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
5949                         }
5950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
5951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
5952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
5953                 }
5954                 if (r->comment) {
5955                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
5956                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
5957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
5958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
5959                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
5960                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
5961                         }
5962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
5963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
5964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
5965                 }
5966         }
5967         return NDR_ERR_SUCCESS;
5968 }
5969
5970 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
5971 {
5972         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
5973         ndr->depth++;
5974         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
5975         ndr_print_ptr(ndr, "name", r->name);
5976         ndr->depth++;
5977         if (r->name) {
5978                 ndr_print_string(ndr, "name", r->name);
5979         }
5980         ndr->depth--;
5981         ndr_print_ptr(ndr, "description", r->description);
5982         ndr->depth++;
5983         if (r->description) {
5984                 ndr_print_string(ndr, "description", r->description);
5985         }
5986         ndr->depth--;
5987         ndr_print_ptr(ndr, "comment", r->comment);
5988         ndr->depth++;
5989         if (r->comment) {
5990                 ndr_print_string(ndr, "comment", r->comment);
5991         }
5992         ndr->depth--;
5993         ndr->depth--;
5994 }
5995
5996 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
5997 {
5998         if (ndr_flags & NDR_SCALARS) {
5999                 NDR_CHECK(ndr_push_align(ndr, 4));
6000                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6002                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6003                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6006                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6007                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6009                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6013                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6018                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6021         }
6022         if (ndr_flags & NDR_BUFFERS) {
6023                 if (r->servername) {
6024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6027                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6028                 }
6029                 if (r->printername) {
6030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6033                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6034                 }
6035                 if (r->sharename) {
6036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6039                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6040                 }
6041                 if (r->portname) {
6042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6045                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6046                 }
6047                 if (r->drivername) {
6048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6051                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6052                 }
6053                 if (r->comment) {
6054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6057                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6058                 }
6059                 if (r->location) {
6060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6063                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6064                 }
6065                 if (r->devmode) {
6066                         {
6067                                 struct ndr_push *_ndr_devmode;
6068                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6069                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6070                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6071                         }
6072                 }
6073                 if (r->sepfile) {
6074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6078                 }
6079                 if (r->printprocessor) {
6080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6084                 }
6085                 if (r->datatype) {
6086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6090                 }
6091                 if (r->parameters) {
6092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6096                 }
6097                 if (r->secdesc) {
6098                         {
6099                                 struct ndr_push *_ndr_secdesc;
6100                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6101                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6102                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6103                         }
6104                 }
6105         }
6106         return NDR_ERR_SUCCESS;
6107 }
6108
6109 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6110 {
6111         uint32_t _ptr_servername;
6112         TALLOC_CTX *_mem_save_servername_0;
6113         uint32_t _ptr_printername;
6114         TALLOC_CTX *_mem_save_printername_0;
6115         uint32_t _ptr_sharename;
6116         TALLOC_CTX *_mem_save_sharename_0;
6117         uint32_t _ptr_portname;
6118         TALLOC_CTX *_mem_save_portname_0;
6119         uint32_t _ptr_drivername;
6120         TALLOC_CTX *_mem_save_drivername_0;
6121         uint32_t _ptr_comment;
6122         TALLOC_CTX *_mem_save_comment_0;
6123         uint32_t _ptr_location;
6124         TALLOC_CTX *_mem_save_location_0;
6125         uint32_t _ptr_devmode;
6126         TALLOC_CTX *_mem_save_devmode_0;
6127         uint32_t _ptr_sepfile;
6128         TALLOC_CTX *_mem_save_sepfile_0;
6129         uint32_t _ptr_printprocessor;
6130         TALLOC_CTX *_mem_save_printprocessor_0;
6131         uint32_t _ptr_datatype;
6132         TALLOC_CTX *_mem_save_datatype_0;
6133         uint32_t _ptr_parameters;
6134         TALLOC_CTX *_mem_save_parameters_0;
6135         uint32_t _ptr_secdesc;
6136         TALLOC_CTX *_mem_save_secdesc_0;
6137         if (ndr_flags & NDR_SCALARS) {
6138                 NDR_CHECK(ndr_pull_align(ndr, 4));
6139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6140                 if (_ptr_servername) {
6141                         NDR_PULL_ALLOC(ndr, r->servername);
6142                 } else {
6143                         r->servername = NULL;
6144                 }
6145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6146                 if (_ptr_printername) {
6147                         NDR_PULL_ALLOC(ndr, r->printername);
6148                 } else {
6149                         r->printername = NULL;
6150                 }
6151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6152                 if (_ptr_sharename) {
6153                         NDR_PULL_ALLOC(ndr, r->sharename);
6154                 } else {
6155                         r->sharename = NULL;
6156                 }
6157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6158                 if (_ptr_portname) {
6159                         NDR_PULL_ALLOC(ndr, r->portname);
6160                 } else {
6161                         r->portname = NULL;
6162                 }
6163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6164                 if (_ptr_drivername) {
6165                         NDR_PULL_ALLOC(ndr, r->drivername);
6166                 } else {
6167                         r->drivername = NULL;
6168                 }
6169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6170                 if (_ptr_comment) {
6171                         NDR_PULL_ALLOC(ndr, r->comment);
6172                 } else {
6173                         r->comment = NULL;
6174                 }
6175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6176                 if (_ptr_location) {
6177                         NDR_PULL_ALLOC(ndr, r->location);
6178                 } else {
6179                         r->location = NULL;
6180                 }
6181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6182                 if (_ptr_devmode) {
6183                         NDR_PULL_ALLOC(ndr, r->devmode);
6184                 } else {
6185                         r->devmode = NULL;
6186                 }
6187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6188                 if (_ptr_sepfile) {
6189                         NDR_PULL_ALLOC(ndr, r->sepfile);
6190                 } else {
6191                         r->sepfile = NULL;
6192                 }
6193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6194                 if (_ptr_printprocessor) {
6195                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6196                 } else {
6197                         r->printprocessor = NULL;
6198                 }
6199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6200                 if (_ptr_datatype) {
6201                         NDR_PULL_ALLOC(ndr, r->datatype);
6202                 } else {
6203                         r->datatype = NULL;
6204                 }
6205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6206                 if (_ptr_parameters) {
6207                         NDR_PULL_ALLOC(ndr, r->parameters);
6208                 } else {
6209                         r->parameters = NULL;
6210                 }
6211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6212                 if (_ptr_secdesc) {
6213                         NDR_PULL_ALLOC(ndr, r->secdesc);
6214                 } else {
6215                         r->secdesc = NULL;
6216                 }
6217                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6222                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6225         }
6226         if (ndr_flags & NDR_BUFFERS) {
6227                 if (r->servername) {
6228                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6229                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6230                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6231                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6232                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6233                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6234                         }
6235                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6236                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6237                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6238                 }
6239                 if (r->printername) {
6240                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6241                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6242                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6243                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6244                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6245                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6246                         }
6247                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6248                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6250                 }
6251                 if (r->sharename) {
6252                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6253                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6254                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6255                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6256                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6257                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
6258                         }
6259                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6260                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6262                 }
6263                 if (r->portname) {
6264                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6265                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6266                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6267                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6268                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6269                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6270                         }
6271                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6272                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6274                 }
6275                 if (r->drivername) {
6276                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6277                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6278                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6279                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6280                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6281                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
6282                         }
6283                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6284                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6286                 }
6287                 if (r->comment) {
6288                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6289                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6291                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6292                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6293                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6294                         }
6295                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6296                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6298                 }
6299                 if (r->location) {
6300                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6301                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6302                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6303                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6304                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6305                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
6306                         }
6307                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6308                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6310                 }
6311                 if (r->devmode) {
6312                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6313                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6314                         {
6315                                 struct ndr_pull *_ndr_devmode;
6316                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6317                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6318                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6319                         }
6320                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6321                 }
6322                 if (r->sepfile) {
6323                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6324                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6325                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6326                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6327                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6328                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
6329                         }
6330                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6331                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6332                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6333                 }
6334                 if (r->printprocessor) {
6335                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6336                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6337                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6338                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6339                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6340                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
6341                         }
6342                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6343                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6344                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6345                 }
6346                 if (r->datatype) {
6347                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6348                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6349                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6350                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6351                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6352                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
6353                         }
6354                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6355                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6356                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6357                 }
6358                 if (r->parameters) {
6359                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6360                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6361                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6362                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6363                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6364                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
6365                         }
6366                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6367                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6368                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6369                 }
6370                 if (r->secdesc) {
6371                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6372                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6373                         {
6374                                 struct ndr_pull *_ndr_secdesc;
6375                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6376                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6377                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6378                         }
6379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6380                 }
6381         }
6382         return NDR_ERR_SUCCESS;
6383 }
6384
6385 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6386 {
6387         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6388         ndr->depth++;
6389         ndr_print_ptr(ndr, "servername", r->servername);
6390         ndr->depth++;
6391         if (r->servername) {
6392                 ndr_print_string(ndr, "servername", r->servername);
6393         }
6394         ndr->depth--;
6395         ndr_print_ptr(ndr, "printername", r->printername);
6396         ndr->depth++;
6397         if (r->printername) {
6398                 ndr_print_string(ndr, "printername", r->printername);
6399         }
6400         ndr->depth--;
6401         ndr_print_ptr(ndr, "sharename", r->sharename);
6402         ndr->depth++;
6403         if (r->sharename) {
6404                 ndr_print_string(ndr, "sharename", r->sharename);
6405         }
6406         ndr->depth--;
6407         ndr_print_ptr(ndr, "portname", r->portname);
6408         ndr->depth++;
6409         if (r->portname) {
6410                 ndr_print_string(ndr, "portname", r->portname);
6411         }
6412         ndr->depth--;
6413         ndr_print_ptr(ndr, "drivername", r->drivername);
6414         ndr->depth++;
6415         if (r->drivername) {
6416                 ndr_print_string(ndr, "drivername", r->drivername);
6417         }
6418         ndr->depth--;
6419         ndr_print_ptr(ndr, "comment", r->comment);
6420         ndr->depth++;
6421         if (r->comment) {
6422                 ndr_print_string(ndr, "comment", r->comment);
6423         }
6424         ndr->depth--;
6425         ndr_print_ptr(ndr, "location", r->location);
6426         ndr->depth++;
6427         if (r->location) {
6428                 ndr_print_string(ndr, "location", r->location);
6429         }
6430         ndr->depth--;
6431         ndr_print_ptr(ndr, "devmode", r->devmode);
6432         ndr->depth++;
6433         if (r->devmode) {
6434                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6435         }
6436         ndr->depth--;
6437         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6438         ndr->depth++;
6439         if (r->sepfile) {
6440                 ndr_print_string(ndr, "sepfile", r->sepfile);
6441         }
6442         ndr->depth--;
6443         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6444         ndr->depth++;
6445         if (r->printprocessor) {
6446                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6447         }
6448         ndr->depth--;
6449         ndr_print_ptr(ndr, "datatype", r->datatype);
6450         ndr->depth++;
6451         if (r->datatype) {
6452                 ndr_print_string(ndr, "datatype", r->datatype);
6453         }
6454         ndr->depth--;
6455         ndr_print_ptr(ndr, "parameters", r->parameters);
6456         ndr->depth++;
6457         if (r->parameters) {
6458                 ndr_print_string(ndr, "parameters", r->parameters);
6459         }
6460         ndr->depth--;
6461         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6462         ndr->depth++;
6463         if (r->secdesc) {
6464                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6465         }
6466         ndr->depth--;
6467         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6468         ndr_print_uint32(ndr, "priority", r->priority);
6469         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6470         ndr_print_uint32(ndr, "starttime", r->starttime);
6471         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6472         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6473         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6474         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6475         ndr->depth--;
6476 }
6477
6478 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6479 {
6480         if (ndr_flags & NDR_SCALARS) {
6481                 NDR_CHECK(ndr_push_align(ndr, 4));
6482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6483         }
6484         if (ndr_flags & NDR_BUFFERS) {
6485         }
6486         return NDR_ERR_SUCCESS;
6487 }
6488
6489 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6490 {
6491         if (ndr_flags & NDR_SCALARS) {
6492                 NDR_CHECK(ndr_pull_align(ndr, 4));
6493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6494         }
6495         if (ndr_flags & NDR_BUFFERS) {
6496         }
6497         return NDR_ERR_SUCCESS;
6498 }
6499
6500 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6501 {
6502         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6503         ndr->depth++;
6504         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6505         ndr->depth--;
6506 }
6507
6508 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6509 {
6510         if (ndr_flags & NDR_SCALARS) {
6511                 NDR_CHECK(ndr_push_align(ndr, 4));
6512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6514                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6515         }
6516         if (ndr_flags & NDR_BUFFERS) {
6517                 if (r->printername) {
6518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6521                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6522                 }
6523                 if (r->servername) {
6524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6528                 }
6529         }
6530         return NDR_ERR_SUCCESS;
6531 }
6532
6533 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6534 {
6535         uint32_t _ptr_printername;
6536         TALLOC_CTX *_mem_save_printername_0;
6537         uint32_t _ptr_servername;
6538         TALLOC_CTX *_mem_save_servername_0;
6539         if (ndr_flags & NDR_SCALARS) {
6540                 NDR_CHECK(ndr_pull_align(ndr, 4));
6541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6542                 if (_ptr_printername) {
6543                         NDR_PULL_ALLOC(ndr, r->printername);
6544                 } else {
6545                         r->printername = NULL;
6546                 }
6547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6548                 if (_ptr_servername) {
6549                         NDR_PULL_ALLOC(ndr, r->servername);
6550                 } else {
6551                         r->servername = NULL;
6552                 }
6553                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6554         }
6555         if (ndr_flags & NDR_BUFFERS) {
6556                 if (r->printername) {
6557                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6558                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6559                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6560                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6561                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6562                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6563                         }
6564                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6565                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6567                 }
6568                 if (r->servername) {
6569                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6570                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6573                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6574                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6575                         }
6576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6579                 }
6580         }
6581         return NDR_ERR_SUCCESS;
6582 }
6583
6584 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6585 {
6586         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6587         ndr->depth++;
6588         ndr_print_ptr(ndr, "printername", r->printername);
6589         ndr->depth++;
6590         if (r->printername) {
6591                 ndr_print_string(ndr, "printername", r->printername);
6592         }
6593         ndr->depth--;
6594         ndr_print_ptr(ndr, "servername", r->servername);
6595         ndr->depth++;
6596         if (r->servername) {
6597                 ndr_print_string(ndr, "servername", r->servername);
6598         }
6599         ndr->depth--;
6600         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6601         ndr->depth--;
6602 }
6603
6604 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6605 {
6606         if (ndr_flags & NDR_SCALARS) {
6607                 NDR_CHECK(ndr_push_align(ndr, 4));
6608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6610                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6613         }
6614         if (ndr_flags & NDR_BUFFERS) {
6615                 if (r->printername) {
6616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6620                 }
6621                 if (r->portname) {
6622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6625                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6626                 }
6627         }
6628         return NDR_ERR_SUCCESS;
6629 }
6630
6631 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6632 {
6633         uint32_t _ptr_printername;
6634         TALLOC_CTX *_mem_save_printername_0;
6635         uint32_t _ptr_portname;
6636         TALLOC_CTX *_mem_save_portname_0;
6637         if (ndr_flags & NDR_SCALARS) {
6638                 NDR_CHECK(ndr_pull_align(ndr, 4));
6639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6640                 if (_ptr_printername) {
6641                         NDR_PULL_ALLOC(ndr, r->printername);
6642                 } else {
6643                         r->printername = NULL;
6644                 }
6645                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6646                 if (_ptr_portname) {
6647                         NDR_PULL_ALLOC(ndr, r->portname);
6648                 } else {
6649                         r->portname = NULL;
6650                 }
6651                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6654         }
6655         if (ndr_flags & NDR_BUFFERS) {
6656                 if (r->printername) {
6657                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6658                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6659                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6660                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6661                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6662                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6663                         }
6664                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6665                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6667                 }
6668                 if (r->portname) {
6669                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6670                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6673                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6674                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6675                         }
6676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6677                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6679                 }
6680         }
6681         return NDR_ERR_SUCCESS;
6682 }
6683
6684 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6685 {
6686         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6687         ndr->depth++;
6688         ndr_print_ptr(ndr, "printername", r->printername);
6689         ndr->depth++;
6690         if (r->printername) {
6691                 ndr_print_string(ndr, "printername", r->printername);
6692         }
6693         ndr->depth--;
6694         ndr_print_ptr(ndr, "portname", r->portname);
6695         ndr->depth++;
6696         if (r->portname) {
6697                 ndr_print_string(ndr, "portname", r->portname);
6698         }
6699         ndr->depth--;
6700         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6701         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6702         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6703         ndr->depth--;
6704 }
6705
6706 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6707 {
6708         if (ndr_flags & NDR_SCALARS) {
6709                 NDR_CHECK(ndr_push_align(ndr, 4));
6710                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6711         }
6712         if (ndr_flags & NDR_BUFFERS) {
6713         }
6714         return NDR_ERR_SUCCESS;
6715 }
6716
6717 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6718 {
6719         if (ndr_flags & NDR_SCALARS) {
6720                 NDR_CHECK(ndr_pull_align(ndr, 4));
6721                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6722         }
6723         if (ndr_flags & NDR_BUFFERS) {
6724         }
6725         return NDR_ERR_SUCCESS;
6726 }
6727
6728 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6729 {
6730         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6731         ndr->depth++;
6732         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6733         ndr->depth--;
6734 }
6735
6736 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6737 {
6738         if (ndr_flags & NDR_SCALARS) {
6739                 NDR_CHECK(ndr_push_align(ndr, 4));
6740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6741                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6742         }
6743         if (ndr_flags & NDR_BUFFERS) {
6744                 if (r->guid) {
6745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6749                 }
6750         }
6751         return NDR_ERR_SUCCESS;
6752 }
6753
6754 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6755 {
6756         uint32_t _ptr_guid;
6757         TALLOC_CTX *_mem_save_guid_0;
6758         if (ndr_flags & NDR_SCALARS) {
6759                 NDR_CHECK(ndr_pull_align(ndr, 4));
6760                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6761                 if (_ptr_guid) {
6762                         NDR_PULL_ALLOC(ndr, r->guid);
6763                 } else {
6764                         r->guid = NULL;
6765                 }
6766                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6767         }
6768         if (ndr_flags & NDR_BUFFERS) {
6769                 if (r->guid) {
6770                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6771                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6772                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6773                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6774                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6775                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
6776                         }
6777                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6778                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6780                 }
6781         }
6782         return NDR_ERR_SUCCESS;
6783 }
6784
6785 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6786 {
6787         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6788         ndr->depth++;
6789         ndr_print_ptr(ndr, "guid", r->guid);
6790         ndr->depth++;
6791         if (r->guid) {
6792                 ndr_print_string(ndr, "guid", r->guid);
6793         }
6794         ndr->depth--;
6795         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6796         ndr->depth--;
6797 }
6798
6799 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6800 {
6801         if (ndr_flags & NDR_SCALARS) {
6802                 int level = ndr_push_get_switch_value(ndr, r);
6803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6804                 switch (level) {
6805                         case 0: {
6806                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6807                         break; }
6808
6809                         case 1: {
6810                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6811                         break; }
6812
6813                         case 2: {
6814                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6815                         break; }
6816
6817                         case 3: {
6818                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6819                         break; }
6820
6821                         case 4: {
6822                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6823                         break; }
6824
6825                         case 5: {
6826                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6827                         break; }
6828
6829                         case 6: {
6830                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6831                         break; }
6832
6833                         case 7: {
6834                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6835                         break; }
6836
6837                         case 8: {
6838                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6839                         break; }
6840
6841                         case 9: {
6842                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6843                         break; }
6844
6845                         default: {
6846                         break; }
6847
6848                 }
6849         }
6850         if (ndr_flags & NDR_BUFFERS) {
6851                 int level = ndr_push_get_switch_value(ndr, r);
6852                 switch (level) {
6853                         case 0:
6854                                 if (r->info0) {
6855                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6856                                 }
6857                         break;
6858
6859                         case 1:
6860                                 if (r->info1) {
6861                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6862                                 }
6863                         break;
6864
6865                         case 2:
6866                                 if (r->info2) {
6867                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6868                                 }
6869                         break;
6870
6871                         case 3:
6872                                 if (r->info3) {
6873                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6874                                 }
6875                         break;
6876
6877                         case 4:
6878                                 if (r->info4) {
6879                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6880                                 }
6881                         break;
6882
6883                         case 5:
6884                                 if (r->info5) {
6885                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6886                                 }
6887                         break;
6888
6889                         case 6:
6890                                 if (r->info6) {
6891                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6892                                 }
6893                         break;
6894
6895                         case 7:
6896                                 if (r->info7) {
6897                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6898                                 }
6899                         break;
6900
6901                         case 8:
6902                                 if (r->info8) {
6903                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6904                                 }
6905                         break;
6906
6907                         case 9:
6908                                 if (r->info9) {
6909                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
6910                                 }
6911                         break;
6912
6913                         default:
6914                         break;
6915
6916                 }
6917         }
6918         return NDR_ERR_SUCCESS;
6919 }
6920
6921 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
6922 {
6923         int level;
6924         uint32_t _level;
6925         TALLOC_CTX *_mem_save_info0_0;
6926         TALLOC_CTX *_mem_save_info1_0;
6927         TALLOC_CTX *_mem_save_info2_0;
6928         TALLOC_CTX *_mem_save_info3_0;
6929         TALLOC_CTX *_mem_save_info4_0;
6930         TALLOC_CTX *_mem_save_info5_0;
6931         TALLOC_CTX *_mem_save_info6_0;
6932         TALLOC_CTX *_mem_save_info7_0;
6933         TALLOC_CTX *_mem_save_info8_0;
6934         TALLOC_CTX *_mem_save_info9_0;
6935         level = ndr_pull_get_switch_value(ndr, r);
6936         if (ndr_flags & NDR_SCALARS) {
6937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6938                 if (_level != level) {
6939                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6940                 }
6941                 switch (level) {
6942                         case 0: {
6943                                 uint32_t _ptr_info0;
6944                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
6945                                 if (_ptr_info0) {
6946                                         NDR_PULL_ALLOC(ndr, r->info0);
6947                                 } else {
6948                                         r->info0 = NULL;
6949                                 }
6950                         break; }
6951
6952                         case 1: {
6953                                 uint32_t _ptr_info1;
6954                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6955                                 if (_ptr_info1) {
6956                                         NDR_PULL_ALLOC(ndr, r->info1);
6957                                 } else {
6958                                         r->info1 = NULL;
6959                                 }
6960                         break; }
6961
6962                         case 2: {
6963                                 uint32_t _ptr_info2;
6964                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6965                                 if (_ptr_info2) {
6966                                         NDR_PULL_ALLOC(ndr, r->info2);
6967                                 } else {
6968                                         r->info2 = NULL;
6969                                 }
6970                         break; }
6971
6972                         case 3: {
6973                                 uint32_t _ptr_info3;
6974                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6975                                 if (_ptr_info3) {
6976                                         NDR_PULL_ALLOC(ndr, r->info3);
6977                                 } else {
6978                                         r->info3 = NULL;
6979                                 }
6980                         break; }
6981
6982                         case 4: {
6983                                 uint32_t _ptr_info4;
6984                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6985                                 if (_ptr_info4) {
6986                                         NDR_PULL_ALLOC(ndr, r->info4);
6987                                 } else {
6988                                         r->info4 = NULL;
6989                                 }
6990                         break; }
6991
6992                         case 5: {
6993                                 uint32_t _ptr_info5;
6994                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
6995                                 if (_ptr_info5) {
6996                                         NDR_PULL_ALLOC(ndr, r->info5);
6997                                 } else {
6998                                         r->info5 = NULL;
6999                                 }
7000                         break; }
7001
7002                         case 6: {
7003                                 uint32_t _ptr_info6;
7004                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7005                                 if (_ptr_info6) {
7006                                         NDR_PULL_ALLOC(ndr, r->info6);
7007                                 } else {
7008                                         r->info6 = NULL;
7009                                 }
7010                         break; }
7011
7012                         case 7: {
7013                                 uint32_t _ptr_info7;
7014                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7015                                 if (_ptr_info7) {
7016                                         NDR_PULL_ALLOC(ndr, r->info7);
7017                                 } else {
7018                                         r->info7 = NULL;
7019                                 }
7020                         break; }
7021
7022                         case 8: {
7023                                 uint32_t _ptr_info8;
7024                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7025                                 if (_ptr_info8) {
7026                                         NDR_PULL_ALLOC(ndr, r->info8);
7027                                 } else {
7028                                         r->info8 = NULL;
7029                                 }
7030                         break; }
7031
7032                         case 9: {
7033                                 uint32_t _ptr_info9;
7034                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7035                                 if (_ptr_info9) {
7036                                         NDR_PULL_ALLOC(ndr, r->info9);
7037                                 } else {
7038                                         r->info9 = NULL;
7039                                 }
7040                         break; }
7041
7042                         default: {
7043                         break; }
7044
7045                 }
7046         }
7047         if (ndr_flags & NDR_BUFFERS) {
7048                 switch (level) {
7049                         case 0:
7050                                 if (r->info0) {
7051                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7052                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7053                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7054                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7055                                 }
7056                         break;
7057
7058                         case 1:
7059                                 if (r->info1) {
7060                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7061                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7062                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7063                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7064                                 }
7065                         break;
7066
7067                         case 2:
7068                                 if (r->info2) {
7069                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7070                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7071                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7072                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7073                                 }
7074                         break;
7075
7076                         case 3:
7077                                 if (r->info3) {
7078                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7079                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7080                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7081                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7082                                 }
7083                         break;
7084
7085                         case 4:
7086                                 if (r->info4) {
7087                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7088                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7089                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7090                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7091                                 }
7092                         break;
7093
7094                         case 5:
7095                                 if (r->info5) {
7096                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7097                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7098                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7099                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7100                                 }
7101                         break;
7102
7103                         case 6:
7104                                 if (r->info6) {
7105                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7106                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7107                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7108                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7109                                 }
7110                         break;
7111
7112                         case 7:
7113                                 if (r->info7) {
7114                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7115                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7116                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7117                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7118                                 }
7119                         break;
7120
7121                         case 8:
7122                                 if (r->info8) {
7123                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7124                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7125                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7126                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7127                                 }
7128                         break;
7129
7130                         case 9:
7131                                 if (r->info9) {
7132                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7133                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7134                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7135                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7136                                 }
7137                         break;
7138
7139                         default:
7140                         break;
7141
7142                 }
7143         }
7144         return NDR_ERR_SUCCESS;
7145 }
7146
7147 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7148 {
7149         int level;
7150         level = ndr_print_get_switch_value(ndr, r);
7151         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7152         switch (level) {
7153                 case 0:
7154                         ndr_print_ptr(ndr, "info0", r->info0);
7155                         ndr->depth++;
7156                         if (r->info0) {
7157                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7158                         }
7159                         ndr->depth--;
7160                 break;
7161
7162                 case 1:
7163                         ndr_print_ptr(ndr, "info1", r->info1);
7164                         ndr->depth++;
7165                         if (r->info1) {
7166                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7167                         }
7168                         ndr->depth--;
7169                 break;
7170
7171                 case 2:
7172                         ndr_print_ptr(ndr, "info2", r->info2);
7173                         ndr->depth++;
7174                         if (r->info2) {
7175                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7176                         }
7177                         ndr->depth--;
7178                 break;
7179
7180                 case 3:
7181                         ndr_print_ptr(ndr, "info3", r->info3);
7182                         ndr->depth++;
7183                         if (r->info3) {
7184                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7185                         }
7186                         ndr->depth--;
7187                 break;
7188
7189                 case 4:
7190                         ndr_print_ptr(ndr, "info4", r->info4);
7191                         ndr->depth++;
7192                         if (r->info4) {
7193                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7194                         }
7195                         ndr->depth--;
7196                 break;
7197
7198                 case 5:
7199                         ndr_print_ptr(ndr, "info5", r->info5);
7200                         ndr->depth++;
7201                         if (r->info5) {
7202                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7203                         }
7204                         ndr->depth--;
7205                 break;
7206
7207                 case 6:
7208                         ndr_print_ptr(ndr, "info6", r->info6);
7209                         ndr->depth++;
7210                         if (r->info6) {
7211                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7212                         }
7213                         ndr->depth--;
7214                 break;
7215
7216                 case 7:
7217                         ndr_print_ptr(ndr, "info7", r->info7);
7218                         ndr->depth++;
7219                         if (r->info7) {
7220                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7221                         }
7222                         ndr->depth--;
7223                 break;
7224
7225                 case 8:
7226                         ndr_print_ptr(ndr, "info8", r->info8);
7227                         ndr->depth++;
7228                         if (r->info8) {
7229                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7230                         }
7231                         ndr->depth--;
7232                 break;
7233
7234                 case 9:
7235                         ndr_print_ptr(ndr, "info9", r->info9);
7236                         ndr->depth++;
7237                         if (r->info9) {
7238                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7239                         }
7240                         ndr->depth--;
7241                 break;
7242
7243                 default:
7244                 break;
7245
7246         }
7247 }
7248
7249 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7250 {
7251         if (ndr_flags & NDR_SCALARS) {
7252                 NDR_CHECK(ndr_push_align(ndr, 4));
7253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7254                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7255                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7256         }
7257         if (ndr_flags & NDR_BUFFERS) {
7258                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7259         }
7260         return NDR_ERR_SUCCESS;
7261 }
7262
7263 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7264 {
7265         if (ndr_flags & NDR_SCALARS) {
7266                 NDR_CHECK(ndr_pull_align(ndr, 4));
7267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7268                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7269                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7270         }
7271         if (ndr_flags & NDR_BUFFERS) {
7272                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7273         }
7274         return NDR_ERR_SUCCESS;
7275 }
7276
7277 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7278 {
7279         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7280         ndr->depth++;
7281         ndr_print_uint32(ndr, "level", r->level);
7282         ndr_print_set_switch_value(ndr, &r->info, r->level);
7283         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7284         ndr->depth--;
7285 }
7286
7287 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7288 {
7289         if (ndr_flags & NDR_SCALARS) {
7290                 NDR_CHECK(ndr_push_align(ndr, 4));
7291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7292                 {
7293                         uint32_t _flags_save_string_array = ndr->flags;
7294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7295                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7296                         ndr->flags = _flags_save_string_array;
7297                 }
7298         }
7299         if (ndr_flags & NDR_BUFFERS) {
7300         }
7301         return NDR_ERR_SUCCESS;
7302 }
7303
7304 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7305 {
7306         if (ndr_flags & NDR_SCALARS) {
7307                 NDR_CHECK(ndr_pull_align(ndr, 4));
7308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7309                 {
7310                         uint32_t _flags_save_string_array = ndr->flags;
7311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7312                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7313                         ndr->flags = _flags_save_string_array;
7314                 }
7315         }
7316         if (ndr_flags & NDR_BUFFERS) {
7317         }
7318         return NDR_ERR_SUCCESS;
7319 }
7320
7321 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7322 {
7323         ndr_print_struct(ndr, name, "spoolss_StringArray");
7324         ndr->depth++;
7325         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
7326         ndr_print_string_array(ndr, "string", r->string);
7327         ndr->depth--;
7328 }
7329
7330 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7331 {
7332         if (ndr_flags & NDR_SCALARS) {
7333                 NDR_CHECK(ndr_push_align(ndr, 4));
7334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7335         }
7336         if (ndr_flags & NDR_BUFFERS) {
7337                 if (r->driver_name) {
7338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7342                 }
7343         }
7344         return NDR_ERR_SUCCESS;
7345 }
7346
7347 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7348 {
7349         uint32_t _ptr_driver_name;
7350         TALLOC_CTX *_mem_save_driver_name_0;
7351         if (ndr_flags & NDR_SCALARS) {
7352                 NDR_CHECK(ndr_pull_align(ndr, 4));
7353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7354                 if (_ptr_driver_name) {
7355                         NDR_PULL_ALLOC(ndr, r->driver_name);
7356                 } else {
7357                         r->driver_name = NULL;
7358                 }
7359         }
7360         if (ndr_flags & NDR_BUFFERS) {
7361                 if (r->driver_name) {
7362                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7363                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7366                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7367                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7368                         }
7369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7372                 }
7373         }
7374         return NDR_ERR_SUCCESS;
7375 }
7376
7377 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7378 {
7379         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7380         ndr->depth++;
7381         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7382         ndr->depth++;
7383         if (r->driver_name) {
7384                 ndr_print_string(ndr, "driver_name", r->driver_name);
7385         }
7386         ndr->depth--;
7387         ndr->depth--;
7388 }
7389
7390 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7391 {
7392         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7393         return NDR_ERR_SUCCESS;
7394 }
7395
7396 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7397 {
7398         uint32_t v;
7399         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7400         *r = v;
7401         return NDR_ERR_SUCCESS;
7402 }
7403
7404 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7405 {
7406         const char *val = NULL;
7407
7408         switch (r) {
7409                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7410                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7411                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7412                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7413         }
7414         ndr_print_enum(ndr, name, "ENUM", val, r);
7415 }
7416
7417 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7418 {
7419         if (ndr_flags & NDR_SCALARS) {
7420                 NDR_CHECK(ndr_push_align(ndr, 4));
7421                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7427         }
7428         if (ndr_flags & NDR_BUFFERS) {
7429                 if (r->driver_name) {
7430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7434                 }
7435                 if (r->architecture) {
7436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7440                 }
7441                 if (r->driver_path) {
7442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7446                 }
7447                 if (r->data_file) {
7448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7452                 }
7453                 if (r->config_file) {
7454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7457                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7458                 }
7459         }
7460         return NDR_ERR_SUCCESS;
7461 }
7462
7463 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7464 {
7465         uint32_t _ptr_driver_name;
7466         TALLOC_CTX *_mem_save_driver_name_0;
7467         uint32_t _ptr_architecture;
7468         TALLOC_CTX *_mem_save_architecture_0;
7469         uint32_t _ptr_driver_path;
7470         TALLOC_CTX *_mem_save_driver_path_0;
7471         uint32_t _ptr_data_file;
7472         TALLOC_CTX *_mem_save_data_file_0;
7473         uint32_t _ptr_config_file;
7474         TALLOC_CTX *_mem_save_config_file_0;
7475         if (ndr_flags & NDR_SCALARS) {
7476                 NDR_CHECK(ndr_pull_align(ndr, 4));
7477                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7479                 if (_ptr_driver_name) {
7480                         NDR_PULL_ALLOC(ndr, r->driver_name);
7481                 } else {
7482                         r->driver_name = NULL;
7483                 }
7484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7485                 if (_ptr_architecture) {
7486                         NDR_PULL_ALLOC(ndr, r->architecture);
7487                 } else {
7488                         r->architecture = NULL;
7489                 }
7490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7491                 if (_ptr_driver_path) {
7492                         NDR_PULL_ALLOC(ndr, r->driver_path);
7493                 } else {
7494                         r->driver_path = NULL;
7495                 }
7496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7497                 if (_ptr_data_file) {
7498                         NDR_PULL_ALLOC(ndr, r->data_file);
7499                 } else {
7500                         r->data_file = NULL;
7501                 }
7502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7503                 if (_ptr_config_file) {
7504                         NDR_PULL_ALLOC(ndr, r->config_file);
7505                 } else {
7506                         r->config_file = NULL;
7507                 }
7508         }
7509         if (ndr_flags & NDR_BUFFERS) {
7510                 if (r->driver_name) {
7511                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7512                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7515                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7516                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7517                         }
7518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7521                 }
7522                 if (r->architecture) {
7523                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7524                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7526                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7527                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7528                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7529                         }
7530                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7531                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7533                 }
7534                 if (r->driver_path) {
7535                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7536                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7539                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7540                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7541                         }
7542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7545                 }
7546                 if (r->data_file) {
7547                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7548                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7549                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7550                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7551                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7552                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7553                         }
7554                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7555                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7557                 }
7558                 if (r->config_file) {
7559                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7560                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7561                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7562                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7563                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7564                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7565                         }
7566                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7567                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7569                 }
7570         }
7571         return NDR_ERR_SUCCESS;
7572 }
7573
7574 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7575 {
7576         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7577         ndr->depth++;
7578         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7579         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7580         ndr->depth++;
7581         if (r->driver_name) {
7582                 ndr_print_string(ndr, "driver_name", r->driver_name);
7583         }
7584         ndr->depth--;
7585         ndr_print_ptr(ndr, "architecture", r->architecture);
7586         ndr->depth++;
7587         if (r->architecture) {
7588                 ndr_print_string(ndr, "architecture", r->architecture);
7589         }
7590         ndr->depth--;
7591         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7592         ndr->depth++;
7593         if (r->driver_path) {
7594                 ndr_print_string(ndr, "driver_path", r->driver_path);
7595         }
7596         ndr->depth--;
7597         ndr_print_ptr(ndr, "data_file", r->data_file);
7598         ndr->depth++;
7599         if (r->data_file) {
7600                 ndr_print_string(ndr, "data_file", r->data_file);
7601         }
7602         ndr->depth--;
7603         ndr_print_ptr(ndr, "config_file", r->config_file);
7604         ndr->depth++;
7605         if (r->config_file) {
7606                 ndr_print_string(ndr, "config_file", r->config_file);
7607         }
7608         ndr->depth--;
7609         ndr->depth--;
7610 }
7611
7612 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7613 {
7614         if (ndr_flags & NDR_SCALARS) {
7615                 NDR_CHECK(ndr_push_align(ndr, 4));
7616                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7627         }
7628         if (ndr_flags & NDR_BUFFERS) {
7629                 if (r->driver_name) {
7630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7631                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7633                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7634                 }
7635                 if (r->architecture) {
7636                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7639                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7640                 }
7641                 if (r->driver_path) {
7642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7644                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7645                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7646                 }
7647                 if (r->data_file) {
7648                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7650                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7651                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7652                 }
7653                 if (r->config_file) {
7654                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7658                 }
7659                 if (r->help_file) {
7660                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7664                 }
7665                 if (r->monitor_name) {
7666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7670                 }
7671                 if (r->default_datatype) {
7672                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7675                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7676                 }
7677                 if (r->dependent_files) {
7678                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7679                 }
7680         }
7681         return NDR_ERR_SUCCESS;
7682 }
7683
7684 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7685 {
7686         uint32_t _ptr_driver_name;
7687         TALLOC_CTX *_mem_save_driver_name_0;
7688         uint32_t _ptr_architecture;
7689         TALLOC_CTX *_mem_save_architecture_0;
7690         uint32_t _ptr_driver_path;
7691         TALLOC_CTX *_mem_save_driver_path_0;
7692         uint32_t _ptr_data_file;
7693         TALLOC_CTX *_mem_save_data_file_0;
7694         uint32_t _ptr_config_file;
7695         TALLOC_CTX *_mem_save_config_file_0;
7696         uint32_t _ptr_help_file;
7697         TALLOC_CTX *_mem_save_help_file_0;
7698         uint32_t _ptr_monitor_name;
7699         TALLOC_CTX *_mem_save_monitor_name_0;
7700         uint32_t _ptr_default_datatype;
7701         TALLOC_CTX *_mem_save_default_datatype_0;
7702         uint32_t _ptr_dependent_files;
7703         TALLOC_CTX *_mem_save_dependent_files_0;
7704         if (ndr_flags & NDR_SCALARS) {
7705                 NDR_CHECK(ndr_pull_align(ndr, 4));
7706                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7708                 if (_ptr_driver_name) {
7709                         NDR_PULL_ALLOC(ndr, r->driver_name);
7710                 } else {
7711                         r->driver_name = NULL;
7712                 }
7713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7714                 if (_ptr_architecture) {
7715                         NDR_PULL_ALLOC(ndr, r->architecture);
7716                 } else {
7717                         r->architecture = NULL;
7718                 }
7719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7720                 if (_ptr_driver_path) {
7721                         NDR_PULL_ALLOC(ndr, r->driver_path);
7722                 } else {
7723                         r->driver_path = NULL;
7724                 }
7725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7726                 if (_ptr_data_file) {
7727                         NDR_PULL_ALLOC(ndr, r->data_file);
7728                 } else {
7729                         r->data_file = NULL;
7730                 }
7731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7732                 if (_ptr_config_file) {
7733                         NDR_PULL_ALLOC(ndr, r->config_file);
7734                 } else {
7735                         r->config_file = NULL;
7736                 }
7737                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7738                 if (_ptr_help_file) {
7739                         NDR_PULL_ALLOC(ndr, r->help_file);
7740                 } else {
7741                         r->help_file = NULL;
7742                 }
7743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7744                 if (_ptr_monitor_name) {
7745                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7746                 } else {
7747                         r->monitor_name = NULL;
7748                 }
7749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7750                 if (_ptr_default_datatype) {
7751                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7752                 } else {
7753                         r->default_datatype = NULL;
7754                 }
7755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7757                 if (_ptr_dependent_files) {
7758                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7759                 } else {
7760                         r->dependent_files = NULL;
7761                 }
7762         }
7763         if (ndr_flags & NDR_BUFFERS) {
7764                 if (r->driver_name) {
7765                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7766                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7767                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7768                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7769                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7770                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7771                         }
7772                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7773                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7775                 }
7776                 if (r->architecture) {
7777                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7778                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7779                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7780                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7781                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7782                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7783                         }
7784                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7785                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7787                 }
7788                 if (r->driver_path) {
7789                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7790                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7793                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7794                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7795                         }
7796                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7797                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7799                 }
7800                 if (r->data_file) {
7801                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7802                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7805                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7806                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7807                         }
7808                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7811                 }
7812                 if (r->config_file) {
7813                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7814                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7816                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7817                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7818                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7819                         }
7820                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7821                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7823                 }
7824                 if (r->help_file) {
7825                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7826                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7827                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7828                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7829                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7830                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
7831                         }
7832                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7833                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7835                 }
7836                 if (r->monitor_name) {
7837                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7838                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7839                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7840                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7841                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7842                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
7843                         }
7844                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7845                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7847                 }
7848                 if (r->default_datatype) {
7849                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7850                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7853                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7854                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
7855                         }
7856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7857                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7859                 }
7860                 if (r->dependent_files) {
7861                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7862                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7863                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7865                 }
7866         }
7867         return NDR_ERR_SUCCESS;
7868 }
7869
7870 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7871 {
7872         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7873         ndr->depth++;
7874         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7875         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7876         ndr->depth++;
7877         if (r->driver_name) {
7878                 ndr_print_string(ndr, "driver_name", r->driver_name);
7879         }
7880         ndr->depth--;
7881         ndr_print_ptr(ndr, "architecture", r->architecture);
7882         ndr->depth++;
7883         if (r->architecture) {
7884                 ndr_print_string(ndr, "architecture", r->architecture);
7885         }
7886         ndr->depth--;
7887         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7888         ndr->depth++;
7889         if (r->driver_path) {
7890                 ndr_print_string(ndr, "driver_path", r->driver_path);
7891         }
7892         ndr->depth--;
7893         ndr_print_ptr(ndr, "data_file", r->data_file);
7894         ndr->depth++;
7895         if (r->data_file) {
7896                 ndr_print_string(ndr, "data_file", r->data_file);
7897         }
7898         ndr->depth--;
7899         ndr_print_ptr(ndr, "config_file", r->config_file);
7900         ndr->depth++;
7901         if (r->config_file) {
7902                 ndr_print_string(ndr, "config_file", r->config_file);
7903         }
7904         ndr->depth--;
7905         ndr_print_ptr(ndr, "help_file", r->help_file);
7906         ndr->depth++;
7907         if (r->help_file) {
7908                 ndr_print_string(ndr, "help_file", r->help_file);
7909         }
7910         ndr->depth--;
7911         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7912         ndr->depth++;
7913         if (r->monitor_name) {
7914                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7915         }
7916         ndr->depth--;
7917         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7918         ndr->depth++;
7919         if (r->default_datatype) {
7920                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7921         }
7922         ndr->depth--;
7923         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
7924         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7925         ndr->depth++;
7926         if (r->dependent_files) {
7927                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
7928         }
7929         ndr->depth--;
7930         ndr->depth--;
7931 }
7932
7933 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
7934 {
7935         if (ndr_flags & NDR_SCALARS) {
7936                 NDR_CHECK(ndr_push_align(ndr, 4));
7937                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7945                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7947                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
7950         }
7951         if (ndr_flags & NDR_BUFFERS) {
7952                 if (r->driver_name) {
7953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7956                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7957                 }
7958                 if (r->architecture) {
7959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7962                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7963                 }
7964                 if (r->driver_path) {
7965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7968                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7969                 }
7970                 if (r->data_file) {
7971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7972                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7974                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7975                 }
7976                 if (r->config_file) {
7977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7978                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7980                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7981                 }
7982                 if (r->help_file) {
7983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7986                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7987                 }
7988                 if (r->monitor_name) {
7989                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7992                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7993                 }
7994                 if (r->default_datatype) {
7995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7998                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7999                 }
8000                 if (r->dependent_files) {
8001                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8002                 }
8003                 if (r->previous_names) {
8004                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8005                 }
8006         }
8007         return NDR_ERR_SUCCESS;
8008 }
8009
8010 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8011 {
8012         uint32_t _ptr_driver_name;
8013         TALLOC_CTX *_mem_save_driver_name_0;
8014         uint32_t _ptr_architecture;
8015         TALLOC_CTX *_mem_save_architecture_0;
8016         uint32_t _ptr_driver_path;
8017         TALLOC_CTX *_mem_save_driver_path_0;
8018         uint32_t _ptr_data_file;
8019         TALLOC_CTX *_mem_save_data_file_0;
8020         uint32_t _ptr_config_file;
8021         TALLOC_CTX *_mem_save_config_file_0;
8022         uint32_t _ptr_help_file;
8023         TALLOC_CTX *_mem_save_help_file_0;
8024         uint32_t _ptr_monitor_name;
8025         TALLOC_CTX *_mem_save_monitor_name_0;
8026         uint32_t _ptr_default_datatype;
8027         TALLOC_CTX *_mem_save_default_datatype_0;
8028         uint32_t _ptr_dependent_files;
8029         TALLOC_CTX *_mem_save_dependent_files_0;
8030         uint32_t _ptr_previous_names;
8031         TALLOC_CTX *_mem_save_previous_names_0;
8032         if (ndr_flags & NDR_SCALARS) {
8033                 NDR_CHECK(ndr_pull_align(ndr, 4));
8034                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8036                 if (_ptr_driver_name) {
8037                         NDR_PULL_ALLOC(ndr, r->driver_name);
8038                 } else {
8039                         r->driver_name = NULL;
8040                 }
8041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8042                 if (_ptr_architecture) {
8043                         NDR_PULL_ALLOC(ndr, r->architecture);
8044                 } else {
8045                         r->architecture = NULL;
8046                 }
8047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8048                 if (_ptr_driver_path) {
8049                         NDR_PULL_ALLOC(ndr, r->driver_path);
8050                 } else {
8051                         r->driver_path = NULL;
8052                 }
8053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8054                 if (_ptr_data_file) {
8055                         NDR_PULL_ALLOC(ndr, r->data_file);
8056                 } else {
8057                         r->data_file = NULL;
8058                 }
8059                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8060                 if (_ptr_config_file) {
8061                         NDR_PULL_ALLOC(ndr, r->config_file);
8062                 } else {
8063                         r->config_file = NULL;
8064                 }
8065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8066                 if (_ptr_help_file) {
8067                         NDR_PULL_ALLOC(ndr, r->help_file);
8068                 } else {
8069                         r->help_file = NULL;
8070                 }
8071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8072                 if (_ptr_monitor_name) {
8073                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8074                 } else {
8075                         r->monitor_name = NULL;
8076                 }
8077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8078                 if (_ptr_default_datatype) {
8079                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8080                 } else {
8081                         r->default_datatype = NULL;
8082                 }
8083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8085                 if (_ptr_dependent_files) {
8086                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8087                 } else {
8088                         r->dependent_files = NULL;
8089                 }
8090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8092                 if (_ptr_previous_names) {
8093                         NDR_PULL_ALLOC(ndr, r->previous_names);
8094                 } else {
8095                         r->previous_names = NULL;
8096                 }
8097         }
8098         if (ndr_flags & NDR_BUFFERS) {
8099                 if (r->driver_name) {
8100                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8101                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8104                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8105                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8106                         }
8107                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8110                 }
8111                 if (r->architecture) {
8112                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8113                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8115                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8116                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8117                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8118                         }
8119                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8120                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8122                 }
8123                 if (r->driver_path) {
8124                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8125                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8126                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8127                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8128                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8129                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8130                         }
8131                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8132                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8134                 }
8135                 if (r->data_file) {
8136                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8137                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8138                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8139                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8140                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8141                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8142                         }
8143                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8144                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8146                 }
8147                 if (r->config_file) {
8148                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8149                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8150                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8151                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8152                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8153                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8154                         }
8155                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8156                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8158                 }
8159                 if (r->help_file) {
8160                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8161                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8164                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8165                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8166                         }
8167                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8168                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8170                 }
8171                 if (r->monitor_name) {
8172                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8173                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8176                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8177                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8178                         }
8179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8182                 }
8183                 if (r->default_datatype) {
8184                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8185                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8186                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8187                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8188                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8189                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8190                         }
8191                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8192                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8194                 }
8195                 if (r->dependent_files) {
8196                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8197                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8198                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8200                 }
8201                 if (r->previous_names) {
8202                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8203                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8204                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8206                 }
8207         }
8208         return NDR_ERR_SUCCESS;
8209 }
8210
8211 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8212 {
8213         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8214         ndr->depth++;
8215         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8216         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8217         ndr->depth++;
8218         if (r->driver_name) {
8219                 ndr_print_string(ndr, "driver_name", r->driver_name);
8220         }
8221         ndr->depth--;
8222         ndr_print_ptr(ndr, "architecture", r->architecture);
8223         ndr->depth++;
8224         if (r->architecture) {
8225                 ndr_print_string(ndr, "architecture", r->architecture);
8226         }
8227         ndr->depth--;
8228         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8229         ndr->depth++;
8230         if (r->driver_path) {
8231                 ndr_print_string(ndr, "driver_path", r->driver_path);
8232         }
8233         ndr->depth--;
8234         ndr_print_ptr(ndr, "data_file", r->data_file);
8235         ndr->depth++;
8236         if (r->data_file) {
8237                 ndr_print_string(ndr, "data_file", r->data_file);
8238         }
8239         ndr->depth--;
8240         ndr_print_ptr(ndr, "config_file", r->config_file);
8241         ndr->depth++;
8242         if (r->config_file) {
8243                 ndr_print_string(ndr, "config_file", r->config_file);
8244         }
8245         ndr->depth--;
8246         ndr_print_ptr(ndr, "help_file", r->help_file);
8247         ndr->depth++;
8248         if (r->help_file) {
8249                 ndr_print_string(ndr, "help_file", r->help_file);
8250         }
8251         ndr->depth--;
8252         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8253         ndr->depth++;
8254         if (r->monitor_name) {
8255                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8256         }
8257         ndr->depth--;
8258         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8259         ndr->depth++;
8260         if (r->default_datatype) {
8261                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8262         }
8263         ndr->depth--;
8264         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8265         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8266         ndr->depth++;
8267         if (r->dependent_files) {
8268                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8269         }
8270         ndr->depth--;
8271         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
8272         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8273         ndr->depth++;
8274         if (r->previous_names) {
8275                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8276         }
8277         ndr->depth--;
8278         ndr->depth--;
8279 }
8280
8281 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8282 {
8283         if (ndr_flags & NDR_SCALARS) {
8284                 NDR_CHECK(ndr_push_align(ndr, 8));
8285                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8286                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8287                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8291                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8293                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8298                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8299                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8300                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8301                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8302                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8303                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8304         }
8305         if (ndr_flags & NDR_BUFFERS) {
8306                 if (r->driver_name) {
8307                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8308                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8309                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8310                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8311                 }
8312                 if (r->architecture) {
8313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8314                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8315                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8316                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8317                 }
8318                 if (r->driver_path) {
8319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8321                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8322                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8323                 }
8324                 if (r->data_file) {
8325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8328                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8329                 }
8330                 if (r->config_file) {
8331                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8334                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8335                 }
8336                 if (r->help_file) {
8337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8341                 }
8342                 if (r->monitor_name) {
8343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8346                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8347                 }
8348                 if (r->default_datatype) {
8349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8352                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8353                 }
8354                 if (r->dependent_files) {
8355                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8356                 }
8357                 if (r->previous_names) {
8358                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8359                 }
8360                 if (r->manufacturer_name) {
8361                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8364                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8365                 }
8366                 if (r->manufacturer_url) {
8367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8371                 }
8372                 if (r->hardware_id) {
8373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8377                 }
8378                 if (r->provider) {
8379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8383                 }
8384         }
8385         return NDR_ERR_SUCCESS;
8386 }
8387
8388 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8389 {
8390         uint32_t _ptr_driver_name;
8391         TALLOC_CTX *_mem_save_driver_name_0;
8392         uint32_t _ptr_architecture;
8393         TALLOC_CTX *_mem_save_architecture_0;
8394         uint32_t _ptr_driver_path;
8395         TALLOC_CTX *_mem_save_driver_path_0;
8396         uint32_t _ptr_data_file;
8397         TALLOC_CTX *_mem_save_data_file_0;
8398         uint32_t _ptr_config_file;
8399         TALLOC_CTX *_mem_save_config_file_0;
8400         uint32_t _ptr_help_file;
8401         TALLOC_CTX *_mem_save_help_file_0;
8402         uint32_t _ptr_monitor_name;
8403         TALLOC_CTX *_mem_save_monitor_name_0;
8404         uint32_t _ptr_default_datatype;
8405         TALLOC_CTX *_mem_save_default_datatype_0;
8406         uint32_t _ptr_dependent_files;
8407         TALLOC_CTX *_mem_save_dependent_files_0;
8408         uint32_t _ptr_previous_names;
8409         TALLOC_CTX *_mem_save_previous_names_0;
8410         uint32_t _ptr_manufacturer_name;
8411         TALLOC_CTX *_mem_save_manufacturer_name_0;
8412         uint32_t _ptr_manufacturer_url;
8413         TALLOC_CTX *_mem_save_manufacturer_url_0;
8414         uint32_t _ptr_hardware_id;
8415         TALLOC_CTX *_mem_save_hardware_id_0;
8416         uint32_t _ptr_provider;
8417         TALLOC_CTX *_mem_save_provider_0;
8418         if (ndr_flags & NDR_SCALARS) {
8419                 NDR_CHECK(ndr_pull_align(ndr, 8));
8420                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8422                 if (_ptr_driver_name) {
8423                         NDR_PULL_ALLOC(ndr, r->driver_name);
8424                 } else {
8425                         r->driver_name = NULL;
8426                 }
8427                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8428                 if (_ptr_architecture) {
8429                         NDR_PULL_ALLOC(ndr, r->architecture);
8430                 } else {
8431                         r->architecture = NULL;
8432                 }
8433                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8434                 if (_ptr_driver_path) {
8435                         NDR_PULL_ALLOC(ndr, r->driver_path);
8436                 } else {
8437                         r->driver_path = NULL;
8438                 }
8439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8440                 if (_ptr_data_file) {
8441                         NDR_PULL_ALLOC(ndr, r->data_file);
8442                 } else {
8443                         r->data_file = NULL;
8444                 }
8445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8446                 if (_ptr_config_file) {
8447                         NDR_PULL_ALLOC(ndr, r->config_file);
8448                 } else {
8449                         r->config_file = NULL;
8450                 }
8451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8452                 if (_ptr_help_file) {
8453                         NDR_PULL_ALLOC(ndr, r->help_file);
8454                 } else {
8455                         r->help_file = NULL;
8456                 }
8457                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8458                 if (_ptr_monitor_name) {
8459                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8460                 } else {
8461                         r->monitor_name = NULL;
8462                 }
8463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8464                 if (_ptr_default_datatype) {
8465                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8466                 } else {
8467                         r->default_datatype = NULL;
8468                 }
8469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8471                 if (_ptr_dependent_files) {
8472                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8473                 } else {
8474                         r->dependent_files = NULL;
8475                 }
8476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8478                 if (_ptr_previous_names) {
8479                         NDR_PULL_ALLOC(ndr, r->previous_names);
8480                 } else {
8481                         r->previous_names = NULL;
8482                 }
8483                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8484                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8486                 if (_ptr_manufacturer_name) {
8487                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8488                 } else {
8489                         r->manufacturer_name = NULL;
8490                 }
8491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8492                 if (_ptr_manufacturer_url) {
8493                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8494                 } else {
8495                         r->manufacturer_url = NULL;
8496                 }
8497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8498                 if (_ptr_hardware_id) {
8499                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8500                 } else {
8501                         r->hardware_id = NULL;
8502                 }
8503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8504                 if (_ptr_provider) {
8505                         NDR_PULL_ALLOC(ndr, r->provider);
8506                 } else {
8507                         r->provider = NULL;
8508                 }
8509         }
8510         if (ndr_flags & NDR_BUFFERS) {
8511                 if (r->driver_name) {
8512                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8513                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8516                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8517                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8518                         }
8519                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8520                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8522                 }
8523                 if (r->architecture) {
8524                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8525                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8528                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8529                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8530                         }
8531                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8532                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8534                 }
8535                 if (r->driver_path) {
8536                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8537                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8540                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8541                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8542                         }
8543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8546                 }
8547                 if (r->data_file) {
8548                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8549                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8552                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8553                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8554                         }
8555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8558                 }
8559                 if (r->config_file) {
8560                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8561                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8564                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8565                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8566                         }
8567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8568                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8570                 }
8571                 if (r->help_file) {
8572                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8573                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8574                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8575                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8576                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8577                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8578                         }
8579                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8580                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8581                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8582                 }
8583                 if (r->monitor_name) {
8584                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8585                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8586                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8587                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8588                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8589                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8590                         }
8591                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8592                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8594                 }
8595                 if (r->default_datatype) {
8596                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8597                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8598                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8599                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8600                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8601                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8602                         }
8603                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8604                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8606                 }
8607                 if (r->dependent_files) {
8608                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8609                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8610                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8611                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8612                 }
8613                 if (r->previous_names) {
8614                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8615                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8616                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8618                 }
8619                 if (r->manufacturer_name) {
8620                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8621                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8622                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8623                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8624                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8625                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
8626                         }
8627                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8628                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8630                 }
8631                 if (r->manufacturer_url) {
8632                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8633                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8634                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8635                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8636                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8637                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
8638                         }
8639                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8640                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8642                 }
8643                 if (r->hardware_id) {
8644                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8645                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8646                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8647                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8648                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8649                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
8650                         }
8651                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8652                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8654                 }
8655                 if (r->provider) {
8656                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8657                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8658                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8659                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8660                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8661                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
8662                         }
8663                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8664                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8665                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8666                 }
8667         }
8668         return NDR_ERR_SUCCESS;
8669 }
8670
8671 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8672 {
8673         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8674         ndr->depth++;
8675         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8676         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8677         ndr->depth++;
8678         if (r->driver_name) {
8679                 ndr_print_string(ndr, "driver_name", r->driver_name);
8680         }
8681         ndr->depth--;
8682         ndr_print_ptr(ndr, "architecture", r->architecture);
8683         ndr->depth++;
8684         if (r->architecture) {
8685                 ndr_print_string(ndr, "architecture", r->architecture);
8686         }
8687         ndr->depth--;
8688         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8689         ndr->depth++;
8690         if (r->driver_path) {
8691                 ndr_print_string(ndr, "driver_path", r->driver_path);
8692         }
8693         ndr->depth--;
8694         ndr_print_ptr(ndr, "data_file", r->data_file);
8695         ndr->depth++;
8696         if (r->data_file) {
8697                 ndr_print_string(ndr, "data_file", r->data_file);
8698         }
8699         ndr->depth--;
8700         ndr_print_ptr(ndr, "config_file", r->config_file);
8701         ndr->depth++;
8702         if (r->config_file) {
8703                 ndr_print_string(ndr, "config_file", r->config_file);
8704         }
8705         ndr->depth--;
8706         ndr_print_ptr(ndr, "help_file", r->help_file);
8707         ndr->depth++;
8708         if (r->help_file) {
8709                 ndr_print_string(ndr, "help_file", r->help_file);
8710         }
8711         ndr->depth--;
8712         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8713         ndr->depth++;
8714         if (r->monitor_name) {
8715                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8716         }
8717         ndr->depth--;
8718         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8719         ndr->depth++;
8720         if (r->default_datatype) {
8721                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8722         }
8723         ndr->depth--;
8724         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8725         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8726         ndr->depth++;
8727         if (r->dependent_files) {
8728                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8729         }
8730         ndr->depth--;
8731         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
8732         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8733         ndr->depth++;
8734         if (r->previous_names) {
8735                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8736         }
8737         ndr->depth--;
8738         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8739         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8740         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8741         ndr->depth++;
8742         if (r->manufacturer_name) {
8743                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8744         }
8745         ndr->depth--;
8746         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8747         ndr->depth++;
8748         if (r->manufacturer_url) {
8749                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8750         }
8751         ndr->depth--;
8752         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8753         ndr->depth++;
8754         if (r->hardware_id) {
8755                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8756         }
8757         ndr->depth--;
8758         ndr_print_ptr(ndr, "provider", r->provider);
8759         ndr->depth++;
8760         if (r->provider) {
8761                 ndr_print_string(ndr, "provider", r->provider);
8762         }
8763         ndr->depth--;
8764         ndr->depth--;
8765 }
8766
8767 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8768 {
8769         if (ndr_flags & NDR_SCALARS) {
8770                 NDR_CHECK(ndr_push_align(ndr, 8));
8771                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8773                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8774                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8776                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8778                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8784                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8785                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8790                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8791                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8793                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8794                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8798                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8799                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8800         }
8801         if (ndr_flags & NDR_BUFFERS) {
8802                 if (r->driver_name) {
8803                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8804                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8806                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8807                 }
8808                 if (r->architecture) {
8809                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8810                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8811                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8812                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8813                 }
8814                 if (r->driver_path) {
8815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8818                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8819                 }
8820                 if (r->data_file) {
8821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8824                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8825                 }
8826                 if (r->config_file) {
8827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8830                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8831                 }
8832                 if (r->help_file) {
8833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8836                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8837                 }
8838                 if (r->monitor_name) {
8839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8843                 }
8844                 if (r->default_datatype) {
8845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8848                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8849                 }
8850                 if (r->dependent_files) {
8851                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8852                 }
8853                 if (r->previous_names) {
8854                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8855                 }
8856                 if (r->manufacturer_name) {
8857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8861                 }
8862                 if (r->manufacturer_url) {
8863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8866                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8867                 }
8868                 if (r->hardware_id) {
8869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8872                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8873                 }
8874                 if (r->provider) {
8875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8876                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8877                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8878                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8879                 }
8880                 if (r->print_processor) {
8881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8883                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8884                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8885                 }
8886                 if (r->vendor_setup) {
8887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8890                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8891                 }
8892                 if (r->color_profiles) {
8893                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8894                 }
8895                 if (r->inf_path) {
8896                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8899                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8900                 }
8901                 if (r->core_driver_dependencies) {
8902                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8903                 }
8904         }
8905         return NDR_ERR_SUCCESS;
8906 }
8907
8908 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
8909 {
8910         uint32_t _ptr_driver_name;
8911         TALLOC_CTX *_mem_save_driver_name_0;
8912         uint32_t _ptr_architecture;
8913         TALLOC_CTX *_mem_save_architecture_0;
8914         uint32_t _ptr_driver_path;
8915         TALLOC_CTX *_mem_save_driver_path_0;
8916         uint32_t _ptr_data_file;
8917         TALLOC_CTX *_mem_save_data_file_0;
8918         uint32_t _ptr_config_file;
8919         TALLOC_CTX *_mem_save_config_file_0;
8920         uint32_t _ptr_help_file;
8921         TALLOC_CTX *_mem_save_help_file_0;
8922         uint32_t _ptr_monitor_name;
8923         TALLOC_CTX *_mem_save_monitor_name_0;
8924         uint32_t _ptr_default_datatype;
8925         TALLOC_CTX *_mem_save_default_datatype_0;
8926         uint32_t _ptr_dependent_files;
8927         TALLOC_CTX *_mem_save_dependent_files_0;
8928         uint32_t _ptr_previous_names;
8929         TALLOC_CTX *_mem_save_previous_names_0;
8930         uint32_t _ptr_manufacturer_name;
8931         TALLOC_CTX *_mem_save_manufacturer_name_0;
8932         uint32_t _ptr_manufacturer_url;
8933         TALLOC_CTX *_mem_save_manufacturer_url_0;
8934         uint32_t _ptr_hardware_id;
8935         TALLOC_CTX *_mem_save_hardware_id_0;
8936         uint32_t _ptr_provider;
8937         TALLOC_CTX *_mem_save_provider_0;
8938         uint32_t _ptr_print_processor;
8939         TALLOC_CTX *_mem_save_print_processor_0;
8940         uint32_t _ptr_vendor_setup;
8941         TALLOC_CTX *_mem_save_vendor_setup_0;
8942         uint32_t _ptr_color_profiles;
8943         TALLOC_CTX *_mem_save_color_profiles_0;
8944         uint32_t _ptr_inf_path;
8945         TALLOC_CTX *_mem_save_inf_path_0;
8946         uint32_t _ptr_core_driver_dependencies;
8947         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
8948         if (ndr_flags & NDR_SCALARS) {
8949                 NDR_CHECK(ndr_pull_align(ndr, 8));
8950                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8951                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8952                 if (_ptr_driver_name) {
8953                         NDR_PULL_ALLOC(ndr, r->driver_name);
8954                 } else {
8955                         r->driver_name = NULL;
8956                 }
8957                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8958                 if (_ptr_architecture) {
8959                         NDR_PULL_ALLOC(ndr, r->architecture);
8960                 } else {
8961                         r->architecture = NULL;
8962                 }
8963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8964                 if (_ptr_driver_path) {
8965                         NDR_PULL_ALLOC(ndr, r->driver_path);
8966                 } else {
8967                         r->driver_path = NULL;
8968                 }
8969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8970                 if (_ptr_data_file) {
8971                         NDR_PULL_ALLOC(ndr, r->data_file);
8972                 } else {
8973                         r->data_file = NULL;
8974                 }
8975                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8976                 if (_ptr_config_file) {
8977                         NDR_PULL_ALLOC(ndr, r->config_file);
8978                 } else {
8979                         r->config_file = NULL;
8980                 }
8981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8982                 if (_ptr_help_file) {
8983                         NDR_PULL_ALLOC(ndr, r->help_file);
8984                 } else {
8985                         r->help_file = NULL;
8986                 }
8987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8988                 if (_ptr_monitor_name) {
8989                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8990                 } else {
8991                         r->monitor_name = NULL;
8992                 }
8993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8994                 if (_ptr_default_datatype) {
8995                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8996                 } else {
8997                         r->default_datatype = NULL;
8998                 }
8999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9001                 if (_ptr_dependent_files) {
9002                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9003                 } else {
9004                         r->dependent_files = NULL;
9005                 }
9006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9008                 if (_ptr_previous_names) {
9009                         NDR_PULL_ALLOC(ndr, r->previous_names);
9010                 } else {
9011                         r->previous_names = NULL;
9012                 }
9013                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9014                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9016                 if (_ptr_manufacturer_name) {
9017                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9018                 } else {
9019                         r->manufacturer_name = NULL;
9020                 }
9021                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9022                 if (_ptr_manufacturer_url) {
9023                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9024                 } else {
9025                         r->manufacturer_url = NULL;
9026                 }
9027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9028                 if (_ptr_hardware_id) {
9029                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9030                 } else {
9031                         r->hardware_id = NULL;
9032                 }
9033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9034                 if (_ptr_provider) {
9035                         NDR_PULL_ALLOC(ndr, r->provider);
9036                 } else {
9037                         r->provider = NULL;
9038                 }
9039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9040                 if (_ptr_print_processor) {
9041                         NDR_PULL_ALLOC(ndr, r->print_processor);
9042                 } else {
9043                         r->print_processor = NULL;
9044                 }
9045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9046                 if (_ptr_vendor_setup) {
9047                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9048                 } else {
9049                         r->vendor_setup = NULL;
9050                 }
9051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9053                 if (_ptr_color_profiles) {
9054                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9055                 } else {
9056                         r->color_profiles = NULL;
9057                 }
9058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9059                 if (_ptr_inf_path) {
9060                         NDR_PULL_ALLOC(ndr, r->inf_path);
9061                 } else {
9062                         r->inf_path = NULL;
9063                 }
9064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9067                 if (_ptr_core_driver_dependencies) {
9068                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9069                 } else {
9070                         r->core_driver_dependencies = NULL;
9071                 }
9072                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9073                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9074         }
9075         if (ndr_flags & NDR_BUFFERS) {
9076                 if (r->driver_name) {
9077                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9078                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9081                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9082                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9083                         }
9084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9087                 }
9088                 if (r->architecture) {
9089                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9090                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9091                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9092                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9093                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9094                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9095                         }
9096                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9097                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9099                 }
9100                 if (r->driver_path) {
9101                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9102                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9105                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9106                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9107                         }
9108                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9109                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9111                 }
9112                 if (r->data_file) {
9113                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9114                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9115                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9116                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9117                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9118                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9119                         }
9120                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9121                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9123                 }
9124                 if (r->config_file) {
9125                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9126                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9127                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9128                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9129                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9130                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9131                         }
9132                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9133                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9135                 }
9136                 if (r->help_file) {
9137                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9138                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9140                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9141                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9142                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9143                         }
9144                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9145                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9147                 }
9148                 if (r->monitor_name) {
9149                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9150                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9152                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9153                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9154                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9155                         }
9156                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9157                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9159                 }
9160                 if (r->default_datatype) {
9161                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9162                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9163                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9164                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9165                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9166                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9167                         }
9168                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9169                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9170                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9171                 }
9172                 if (r->dependent_files) {
9173                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9174                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9175                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9177                 }
9178                 if (r->previous_names) {
9179                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9180                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9181                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9183                 }
9184                 if (r->manufacturer_name) {
9185                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9186                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9188                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9189                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9190                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9191                         }
9192                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9193                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9195                 }
9196                 if (r->manufacturer_url) {
9197                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9198                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9201                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9202                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9203                         }
9204                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9205                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9207                 }
9208                 if (r->hardware_id) {
9209                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9210                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9213                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9214                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9215                         }
9216                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9217                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9219                 }
9220                 if (r->provider) {
9221                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9222                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9223                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9224                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9225                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9226                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9227                         }
9228                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9229                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9231                 }
9232                 if (r->print_processor) {
9233                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9234                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9235                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9236                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9237                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9238                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
9239                         }
9240                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9241                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9242                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9243                 }
9244                 if (r->vendor_setup) {
9245                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9246                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9247                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9248                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9249                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9250                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
9251                         }
9252                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9253                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9254                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9255                 }
9256                 if (r->color_profiles) {
9257                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9258                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9259                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9261                 }
9262                 if (r->inf_path) {
9263                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9264                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9266                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9267                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9268                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
9269                         }
9270                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9271                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9273                 }
9274                 if (r->core_driver_dependencies) {
9275                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9276                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9277                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9279                 }
9280         }
9281         return NDR_ERR_SUCCESS;
9282 }
9283
9284 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9285 {
9286         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9287         ndr->depth++;
9288         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9289         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9290         ndr->depth++;
9291         if (r->driver_name) {
9292                 ndr_print_string(ndr, "driver_name", r->driver_name);
9293         }
9294         ndr->depth--;
9295         ndr_print_ptr(ndr, "architecture", r->architecture);
9296         ndr->depth++;
9297         if (r->architecture) {
9298                 ndr_print_string(ndr, "architecture", r->architecture);
9299         }
9300         ndr->depth--;
9301         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9302         ndr->depth++;
9303         if (r->driver_path) {
9304                 ndr_print_string(ndr, "driver_path", r->driver_path);
9305         }
9306         ndr->depth--;
9307         ndr_print_ptr(ndr, "data_file", r->data_file);
9308         ndr->depth++;
9309         if (r->data_file) {
9310                 ndr_print_string(ndr, "data_file", r->data_file);
9311         }
9312         ndr->depth--;
9313         ndr_print_ptr(ndr, "config_file", r->config_file);
9314         ndr->depth++;
9315         if (r->config_file) {
9316                 ndr_print_string(ndr, "config_file", r->config_file);
9317         }
9318         ndr->depth--;
9319         ndr_print_ptr(ndr, "help_file", r->help_file);
9320         ndr->depth++;
9321         if (r->help_file) {
9322                 ndr_print_string(ndr, "help_file", r->help_file);
9323         }
9324         ndr->depth--;
9325         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9326         ndr->depth++;
9327         if (r->monitor_name) {
9328                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9329         }
9330         ndr->depth--;
9331         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9332         ndr->depth++;
9333         if (r->default_datatype) {
9334                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9335         }
9336         ndr->depth--;
9337         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9338         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9339         ndr->depth++;
9340         if (r->dependent_files) {
9341                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9342         }
9343         ndr->depth--;
9344         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9345         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9346         ndr->depth++;
9347         if (r->previous_names) {
9348                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9349         }
9350         ndr->depth--;
9351         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9352         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9353         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9354         ndr->depth++;
9355         if (r->manufacturer_name) {
9356                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9357         }
9358         ndr->depth--;
9359         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9360         ndr->depth++;
9361         if (r->manufacturer_url) {
9362                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9363         }
9364         ndr->depth--;
9365         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9366         ndr->depth++;
9367         if (r->hardware_id) {
9368                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9369         }
9370         ndr->depth--;
9371         ndr_print_ptr(ndr, "provider", r->provider);
9372         ndr->depth++;
9373         if (r->provider) {
9374                 ndr_print_string(ndr, "provider", r->provider);
9375         }
9376         ndr->depth--;
9377         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9378         ndr->depth++;
9379         if (r->print_processor) {
9380                 ndr_print_string(ndr, "print_processor", r->print_processor);
9381         }
9382         ndr->depth--;
9383         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9384         ndr->depth++;
9385         if (r->vendor_setup) {
9386                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9387         }
9388         ndr->depth--;
9389         ndr_print_uint32(ndr, "_ndr_size_color_profiles", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_color_profiles);
9390         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9391         ndr->depth++;
9392         if (r->color_profiles) {
9393                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9394         }
9395         ndr->depth--;
9396         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9397         ndr->depth++;
9398         if (r->inf_path) {
9399                 ndr_print_string(ndr, "inf_path", r->inf_path);
9400         }
9401         ndr->depth--;
9402         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9403         ndr_print_uint32(ndr, "_ndr_size_core_driver_dependencies", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_core_driver_dependencies);
9404         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9405         ndr->depth++;
9406         if (r->core_driver_dependencies) {
9407                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9408         }
9409         ndr->depth--;
9410         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9411         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9412         ndr->depth--;
9413 }
9414
9415 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9416 {
9417         if (ndr_flags & NDR_SCALARS) {
9418                 int level = ndr_push_get_switch_value(ndr, r);
9419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9420                 switch (level) {
9421                         case 1: {
9422                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9423                         break; }
9424
9425                         case 2: {
9426                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9427                         break; }
9428
9429                         case 3: {
9430                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9431                         break; }
9432
9433                         case 4: {
9434                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9435                         break; }
9436
9437                         case 6: {
9438                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9439                         break; }
9440
9441                         case 8: {
9442                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9443                         break; }
9444
9445                         default:
9446                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9447                 }
9448         }
9449         if (ndr_flags & NDR_BUFFERS) {
9450                 int level = ndr_push_get_switch_value(ndr, r);
9451                 switch (level) {
9452                         case 1:
9453                                 if (r->info1) {
9454                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9455                                 }
9456                         break;
9457
9458                         case 2:
9459                                 if (r->info2) {
9460                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9461                                 }
9462                         break;
9463
9464                         case 3:
9465                                 if (r->info3) {
9466                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9467                                 }
9468                         break;
9469
9470                         case 4:
9471                                 if (r->info4) {
9472                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9473                                 }
9474                         break;
9475
9476                         case 6:
9477                                 if (r->info6) {
9478                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9479                                 }
9480                         break;
9481
9482                         case 8:
9483                                 if (r->info8) {
9484                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9485                                 }
9486                         break;
9487
9488                         default:
9489                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9490                 }
9491         }
9492         return NDR_ERR_SUCCESS;
9493 }
9494
9495 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9496 {
9497         int level;
9498         uint32_t _level;
9499         TALLOC_CTX *_mem_save_info1_0;
9500         TALLOC_CTX *_mem_save_info2_0;
9501         TALLOC_CTX *_mem_save_info3_0;
9502         TALLOC_CTX *_mem_save_info4_0;
9503         TALLOC_CTX *_mem_save_info6_0;
9504         TALLOC_CTX *_mem_save_info8_0;
9505         level = ndr_pull_get_switch_value(ndr, r);
9506         if (ndr_flags & NDR_SCALARS) {
9507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9508                 if (_level != level) {
9509                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9510                 }
9511                 switch (level) {
9512                         case 1: {
9513                                 uint32_t _ptr_info1;
9514                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9515                                 if (_ptr_info1) {
9516                                         NDR_PULL_ALLOC(ndr, r->info1);
9517                                 } else {
9518                                         r->info1 = NULL;
9519                                 }
9520                         break; }
9521
9522                         case 2: {
9523                                 uint32_t _ptr_info2;
9524                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9525                                 if (_ptr_info2) {
9526                                         NDR_PULL_ALLOC(ndr, r->info2);
9527                                 } else {
9528                                         r->info2 = NULL;
9529                                 }
9530                         break; }
9531
9532                         case 3: {
9533                                 uint32_t _ptr_info3;
9534                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9535                                 if (_ptr_info3) {
9536                                         NDR_PULL_ALLOC(ndr, r->info3);
9537                                 } else {
9538                                         r->info3 = NULL;
9539                                 }
9540                         break; }
9541
9542                         case 4: {
9543                                 uint32_t _ptr_info4;
9544                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9545                                 if (_ptr_info4) {
9546                                         NDR_PULL_ALLOC(ndr, r->info4);
9547                                 } else {
9548                                         r->info4 = NULL;
9549                                 }
9550                         break; }
9551
9552                         case 6: {
9553                                 uint32_t _ptr_info6;
9554                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9555                                 if (_ptr_info6) {
9556                                         NDR_PULL_ALLOC(ndr, r->info6);
9557                                 } else {
9558                                         r->info6 = NULL;
9559                                 }
9560                         break; }
9561
9562                         case 8: {
9563                                 uint32_t _ptr_info8;
9564                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9565                                 if (_ptr_info8) {
9566                                         NDR_PULL_ALLOC(ndr, r->info8);
9567                                 } else {
9568                                         r->info8 = NULL;
9569                                 }
9570                         break; }
9571
9572                         default:
9573                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9574                 }
9575         }
9576         if (ndr_flags & NDR_BUFFERS) {
9577                 switch (level) {
9578                         case 1:
9579                                 if (r->info1) {
9580                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9581                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9582                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9583                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9584                                 }
9585                         break;
9586
9587                         case 2:
9588                                 if (r->info2) {
9589                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9590                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9591                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9592                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9593                                 }
9594                         break;
9595
9596                         case 3:
9597                                 if (r->info3) {
9598                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9599                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9600                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9601                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9602                                 }
9603                         break;
9604
9605                         case 4:
9606                                 if (r->info4) {
9607                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9608                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9609                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9610                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9611                                 }
9612                         break;
9613
9614                         case 6:
9615                                 if (r->info6) {
9616                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9617                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9618                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9619                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9620                                 }
9621                         break;
9622
9623                         case 8:
9624                                 if (r->info8) {
9625                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9626                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9627                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9628                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9629                                 }
9630                         break;
9631
9632                         default:
9633                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9634                 }
9635         }
9636         return NDR_ERR_SUCCESS;
9637 }
9638
9639 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9640 {
9641         int level;
9642         level = ndr_print_get_switch_value(ndr, r);
9643         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9644         switch (level) {
9645                 case 1:
9646                         ndr_print_ptr(ndr, "info1", r->info1);
9647                         ndr->depth++;
9648                         if (r->info1) {
9649                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9650                         }
9651                         ndr->depth--;
9652                 break;
9653
9654                 case 2:
9655                         ndr_print_ptr(ndr, "info2", r->info2);
9656                         ndr->depth++;
9657                         if (r->info2) {
9658                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9659                         }
9660                         ndr->depth--;
9661                 break;
9662
9663                 case 3:
9664                         ndr_print_ptr(ndr, "info3", r->info3);
9665                         ndr->depth++;
9666                         if (r->info3) {
9667                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9668                         }
9669                         ndr->depth--;
9670                 break;
9671
9672                 case 4:
9673                         ndr_print_ptr(ndr, "info4", r->info4);
9674                         ndr->depth++;
9675                         if (r->info4) {
9676                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9677                         }
9678                         ndr->depth--;
9679                 break;
9680
9681                 case 6:
9682                         ndr_print_ptr(ndr, "info6", r->info6);
9683                         ndr->depth++;
9684                         if (r->info6) {
9685                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9686                         }
9687                         ndr->depth--;
9688                 break;
9689
9690                 case 8:
9691                         ndr_print_ptr(ndr, "info8", r->info8);
9692                         ndr->depth++;
9693                         if (r->info8) {
9694                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9695                         }
9696                         ndr->depth--;
9697                 break;
9698
9699                 default:
9700                         ndr_print_bad_level(ndr, name, level);
9701         }
9702 }
9703
9704 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9705 {
9706         if (ndr_flags & NDR_SCALARS) {
9707                 NDR_CHECK(ndr_push_align(ndr, 4));
9708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9709                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9710                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9711         }
9712         if (ndr_flags & NDR_BUFFERS) {
9713                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9714         }
9715         return NDR_ERR_SUCCESS;
9716 }
9717
9718 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9719 {
9720         if (ndr_flags & NDR_SCALARS) {
9721                 NDR_CHECK(ndr_pull_align(ndr, 4));
9722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9723                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9724                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9725         }
9726         if (ndr_flags & NDR_BUFFERS) {
9727                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9728         }
9729         return NDR_ERR_SUCCESS;
9730 }
9731
9732 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9733 {
9734         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9735         ndr->depth++;
9736         ndr_print_uint32(ndr, "level", r->level);
9737         ndr_print_set_switch_value(ndr, &r->info, r->level);
9738         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9739         ndr->depth--;
9740 }
9741
9742 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9743 {
9744         if (ndr_flags & NDR_SCALARS) {
9745                 NDR_CHECK(ndr_push_align(ndr, 4));
9746                 {
9747                         uint32_t _flags_save_string = ndr->flags;
9748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9749                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9750                         ndr->flags = _flags_save_string;
9751                 }
9752         }
9753         if (ndr_flags & NDR_BUFFERS) {
9754                 {
9755                         uint32_t _flags_save_string = ndr->flags;
9756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9757                         if (r->driver_name) {
9758                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9759                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9760                         }
9761                         ndr->flags = _flags_save_string;
9762                 }
9763         }
9764         return NDR_ERR_SUCCESS;
9765 }
9766
9767 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9768 {
9769         uint32_t _ptr_driver_name;
9770         TALLOC_CTX *_mem_save_driver_name_0;
9771         if (ndr_flags & NDR_SCALARS) {
9772                 NDR_CHECK(ndr_pull_align(ndr, 4));
9773                 {
9774                         uint32_t _flags_save_string = ndr->flags;
9775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9777                         if (_ptr_driver_name) {
9778                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9780                         } else {
9781                                 r->driver_name = NULL;
9782                         }
9783                         ndr->flags = _flags_save_string;
9784                 }
9785         }
9786         if (ndr_flags & NDR_BUFFERS) {
9787                 {
9788                         uint32_t _flags_save_string = ndr->flags;
9789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9790                         if (r->driver_name) {
9791                                 uint32_t _relative_save_offset;
9792                                 _relative_save_offset = ndr->offset;
9793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9794                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9795                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9798                                 ndr->offset = _relative_save_offset;
9799                         }
9800                         ndr->flags = _flags_save_string;
9801                 }
9802         }
9803         return NDR_ERR_SUCCESS;
9804 }
9805
9806 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9807 {
9808         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9809         ndr->depth++;
9810         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9811         ndr->depth++;
9812         if (r->driver_name) {
9813                 ndr_print_string(ndr, "driver_name", r->driver_name);
9814         }
9815         ndr->depth--;
9816         ndr->depth--;
9817 }
9818
9819 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9820 {
9821         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9822 }
9823
9824 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9825 {
9826         if (ndr_flags & NDR_SCALARS) {
9827                 NDR_CHECK(ndr_push_align(ndr, 4));
9828                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9829                 {
9830                         uint32_t _flags_save_string = ndr->flags;
9831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9832                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9833                         ndr->flags = _flags_save_string;
9834                 }
9835                 {
9836                         uint32_t _flags_save_string = ndr->flags;
9837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9838                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9839                         ndr->flags = _flags_save_string;
9840                 }
9841                 {
9842                         uint32_t _flags_save_string = ndr->flags;
9843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9844                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9845                         ndr->flags = _flags_save_string;
9846                 }
9847                 {
9848                         uint32_t _flags_save_string = ndr->flags;
9849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9850                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9851                         ndr->flags = _flags_save_string;
9852                 }
9853                 {
9854                         uint32_t _flags_save_string = ndr->flags;
9855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9856                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9857                         ndr->flags = _flags_save_string;
9858                 }
9859         }
9860         if (ndr_flags & NDR_BUFFERS) {
9861                 {
9862                         uint32_t _flags_save_string = ndr->flags;
9863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9864                         if (r->driver_name) {
9865                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9866                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9867                         }
9868                         ndr->flags = _flags_save_string;
9869                 }
9870                 {
9871                         uint32_t _flags_save_string = ndr->flags;
9872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9873                         if (r->architecture) {
9874                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9875                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9876                         }
9877                         ndr->flags = _flags_save_string;
9878                 }
9879                 {
9880                         uint32_t _flags_save_string = ndr->flags;
9881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9882                         if (r->driver_path) {
9883                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9884                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9885                         }
9886                         ndr->flags = _flags_save_string;
9887                 }
9888                 {
9889                         uint32_t _flags_save_string = ndr->flags;
9890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9891                         if (r->data_file) {
9892                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9893                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9894                         }
9895                         ndr->flags = _flags_save_string;
9896                 }
9897                 {
9898                         uint32_t _flags_save_string = ndr->flags;
9899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9900                         if (r->config_file) {
9901                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9902                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9903                         }
9904                         ndr->flags = _flags_save_string;
9905                 }
9906         }
9907         return NDR_ERR_SUCCESS;
9908 }
9909
9910 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
9911 {
9912         uint32_t _ptr_driver_name;
9913         TALLOC_CTX *_mem_save_driver_name_0;
9914         uint32_t _ptr_architecture;
9915         TALLOC_CTX *_mem_save_architecture_0;
9916         uint32_t _ptr_driver_path;
9917         TALLOC_CTX *_mem_save_driver_path_0;
9918         uint32_t _ptr_data_file;
9919         TALLOC_CTX *_mem_save_data_file_0;
9920         uint32_t _ptr_config_file;
9921         TALLOC_CTX *_mem_save_config_file_0;
9922         if (ndr_flags & NDR_SCALARS) {
9923                 NDR_CHECK(ndr_pull_align(ndr, 4));
9924                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9925                 {
9926                         uint32_t _flags_save_string = ndr->flags;
9927                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9928                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9929                         if (_ptr_driver_name) {
9930                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9931                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9932                         } else {
9933                                 r->driver_name = NULL;
9934                         }
9935                         ndr->flags = _flags_save_string;
9936                 }
9937                 {
9938                         uint32_t _flags_save_string = ndr->flags;
9939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9940                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9941                         if (_ptr_architecture) {
9942                                 NDR_PULL_ALLOC(ndr, r->architecture);
9943                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9944                         } else {
9945                                 r->architecture = NULL;
9946                         }
9947                         ndr->flags = _flags_save_string;
9948                 }
9949                 {
9950                         uint32_t _flags_save_string = ndr->flags;
9951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9952                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9953                         if (_ptr_driver_path) {
9954                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9955                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9956                         } else {
9957                                 r->driver_path = NULL;
9958                         }
9959                         ndr->flags = _flags_save_string;
9960                 }
9961                 {
9962                         uint32_t _flags_save_string = ndr->flags;
9963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9964                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9965                         if (_ptr_data_file) {
9966                                 NDR_PULL_ALLOC(ndr, r->data_file);
9967                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9968                         } else {
9969                                 r->data_file = NULL;
9970                         }
9971                         ndr->flags = _flags_save_string;
9972                 }
9973                 {
9974                         uint32_t _flags_save_string = ndr->flags;
9975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9976                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9977                         if (_ptr_config_file) {
9978                                 NDR_PULL_ALLOC(ndr, r->config_file);
9979                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9980                         } else {
9981                                 r->config_file = NULL;
9982                         }
9983                         ndr->flags = _flags_save_string;
9984                 }
9985         }
9986         if (ndr_flags & NDR_BUFFERS) {
9987                 {
9988                         uint32_t _flags_save_string = ndr->flags;
9989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9990                         if (r->driver_name) {
9991                                 uint32_t _relative_save_offset;
9992                                 _relative_save_offset = ndr->offset;
9993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9994                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9995                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9998                                 ndr->offset = _relative_save_offset;
9999                         }
10000                         ndr->flags = _flags_save_string;
10001                 }
10002                 {
10003                         uint32_t _flags_save_string = ndr->flags;
10004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10005                         if (r->architecture) {
10006                                 uint32_t _relative_save_offset;
10007                                 _relative_save_offset = ndr->offset;
10008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10009                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10010                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10013                                 ndr->offset = _relative_save_offset;
10014                         }
10015                         ndr->flags = _flags_save_string;
10016                 }
10017                 {
10018                         uint32_t _flags_save_string = ndr->flags;
10019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10020                         if (r->driver_path) {
10021                                 uint32_t _relative_save_offset;
10022                                 _relative_save_offset = ndr->offset;
10023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10024                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10025                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10026                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10028                                 ndr->offset = _relative_save_offset;
10029                         }
10030                         ndr->flags = _flags_save_string;
10031                 }
10032                 {
10033                         uint32_t _flags_save_string = ndr->flags;
10034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10035                         if (r->data_file) {
10036                                 uint32_t _relative_save_offset;
10037                                 _relative_save_offset = ndr->offset;
10038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10039                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10040                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10043                                 ndr->offset = _relative_save_offset;
10044                         }
10045                         ndr->flags = _flags_save_string;
10046                 }
10047                 {
10048                         uint32_t _flags_save_string = ndr->flags;
10049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10050                         if (r->config_file) {
10051                                 uint32_t _relative_save_offset;
10052                                 _relative_save_offset = ndr->offset;
10053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10054                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10055                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10058                                 ndr->offset = _relative_save_offset;
10059                         }
10060                         ndr->flags = _flags_save_string;
10061                 }
10062         }
10063         return NDR_ERR_SUCCESS;
10064 }
10065
10066 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10067 {
10068         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10069         ndr->depth++;
10070         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10071         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10072         ndr->depth++;
10073         if (r->driver_name) {
10074                 ndr_print_string(ndr, "driver_name", r->driver_name);
10075         }
10076         ndr->depth--;
10077         ndr_print_ptr(ndr, "architecture", r->architecture);
10078         ndr->depth++;
10079         if (r->architecture) {
10080                 ndr_print_string(ndr, "architecture", r->architecture);
10081         }
10082         ndr->depth--;
10083         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10084         ndr->depth++;
10085         if (r->driver_path) {
10086                 ndr_print_string(ndr, "driver_path", r->driver_path);
10087         }
10088         ndr->depth--;
10089         ndr_print_ptr(ndr, "data_file", r->data_file);
10090         ndr->depth++;
10091         if (r->data_file) {
10092                 ndr_print_string(ndr, "data_file", r->data_file);
10093         }
10094         ndr->depth--;
10095         ndr_print_ptr(ndr, "config_file", r->config_file);
10096         ndr->depth++;
10097         if (r->config_file) {
10098                 ndr_print_string(ndr, "config_file", r->config_file);
10099         }
10100         ndr->depth--;
10101         ndr->depth--;
10102 }
10103
10104 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10105 {
10106         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10107 }
10108
10109 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10110 {
10111         if (ndr_flags & NDR_SCALARS) {
10112                 NDR_CHECK(ndr_push_align(ndr, 4));
10113                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10114                 {
10115                         uint32_t _flags_save_string = ndr->flags;
10116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10117                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10118                         ndr->flags = _flags_save_string;
10119                 }
10120                 {
10121                         uint32_t _flags_save_string = ndr->flags;
10122                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10123                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10124                         ndr->flags = _flags_save_string;
10125                 }
10126                 {
10127                         uint32_t _flags_save_string = ndr->flags;
10128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10129                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10130                         ndr->flags = _flags_save_string;
10131                 }
10132                 {
10133                         uint32_t _flags_save_string = ndr->flags;
10134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10135                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10136                         ndr->flags = _flags_save_string;
10137                 }
10138                 {
10139                         uint32_t _flags_save_string = ndr->flags;
10140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10141                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10142                         ndr->flags = _flags_save_string;
10143                 }
10144                 {
10145                         uint32_t _flags_save_string = ndr->flags;
10146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10147                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10148                         ndr->flags = _flags_save_string;
10149                 }
10150                 {
10151                         uint32_t _flags_save_string_array = ndr->flags;
10152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10153                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10154                         ndr->flags = _flags_save_string_array;
10155                 }
10156                 {
10157                         uint32_t _flags_save_string = ndr->flags;
10158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10159                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10160                         ndr->flags = _flags_save_string;
10161                 }
10162                 {
10163                         uint32_t _flags_save_string = ndr->flags;
10164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10165                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10166                         ndr->flags = _flags_save_string;
10167                 }
10168         }
10169         if (ndr_flags & NDR_BUFFERS) {
10170                 {
10171                         uint32_t _flags_save_string = ndr->flags;
10172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10173                         if (r->driver_name) {
10174                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10175                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10176                         }
10177                         ndr->flags = _flags_save_string;
10178                 }
10179                 {
10180                         uint32_t _flags_save_string = ndr->flags;
10181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10182                         if (r->architecture) {
10183                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10184                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10185                         }
10186                         ndr->flags = _flags_save_string;
10187                 }
10188                 {
10189                         uint32_t _flags_save_string = ndr->flags;
10190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10191                         if (r->driver_path) {
10192                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10193                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10194                         }
10195                         ndr->flags = _flags_save_string;
10196                 }
10197                 {
10198                         uint32_t _flags_save_string = ndr->flags;
10199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10200                         if (r->data_file) {
10201                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10202                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10203                         }
10204                         ndr->flags = _flags_save_string;
10205                 }
10206                 {
10207                         uint32_t _flags_save_string = ndr->flags;
10208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10209                         if (r->config_file) {
10210                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10211                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10212                         }
10213                         ndr->flags = _flags_save_string;
10214                 }
10215                 {
10216                         uint32_t _flags_save_string = ndr->flags;
10217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10218                         if (r->help_file) {
10219                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10220                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10221                         }
10222                         ndr->flags = _flags_save_string;
10223                 }
10224                 {
10225                         uint32_t _flags_save_string_array = ndr->flags;
10226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10227                         if (r->dependent_files) {
10228                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10229                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10230                         }
10231                         ndr->flags = _flags_save_string_array;
10232                 }
10233                 {
10234                         uint32_t _flags_save_string = ndr->flags;
10235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10236                         if (r->monitor_name) {
10237                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10238                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10239                         }
10240                         ndr->flags = _flags_save_string;
10241                 }
10242                 {
10243                         uint32_t _flags_save_string = ndr->flags;
10244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10245                         if (r->default_datatype) {
10246                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10247                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10248                         }
10249                         ndr->flags = _flags_save_string;
10250                 }
10251         }
10252         return NDR_ERR_SUCCESS;
10253 }
10254
10255 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10256 {
10257         uint32_t _ptr_driver_name;
10258         TALLOC_CTX *_mem_save_driver_name_0;
10259         uint32_t _ptr_architecture;
10260         TALLOC_CTX *_mem_save_architecture_0;
10261         uint32_t _ptr_driver_path;
10262         TALLOC_CTX *_mem_save_driver_path_0;
10263         uint32_t _ptr_data_file;
10264         TALLOC_CTX *_mem_save_data_file_0;
10265         uint32_t _ptr_config_file;
10266         TALLOC_CTX *_mem_save_config_file_0;
10267         uint32_t _ptr_help_file;
10268         TALLOC_CTX *_mem_save_help_file_0;
10269         uint32_t _ptr_dependent_files;
10270         TALLOC_CTX *_mem_save_dependent_files_0;
10271         uint32_t _ptr_monitor_name;
10272         TALLOC_CTX *_mem_save_monitor_name_0;
10273         uint32_t _ptr_default_datatype;
10274         TALLOC_CTX *_mem_save_default_datatype_0;
10275         if (ndr_flags & NDR_SCALARS) {
10276                 NDR_CHECK(ndr_pull_align(ndr, 4));
10277                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10278                 {
10279                         uint32_t _flags_save_string = ndr->flags;
10280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10281                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10282                         if (_ptr_driver_name) {
10283                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10284                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10285                         } else {
10286                                 r->driver_name = NULL;
10287                         }
10288                         ndr->flags = _flags_save_string;
10289                 }
10290                 {
10291                         uint32_t _flags_save_string = ndr->flags;
10292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10293                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10294                         if (_ptr_architecture) {
10295                                 NDR_PULL_ALLOC(ndr, r->architecture);
10296                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10297                         } else {
10298                                 r->architecture = NULL;
10299                         }
10300                         ndr->flags = _flags_save_string;
10301                 }
10302                 {
10303                         uint32_t _flags_save_string = ndr->flags;
10304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10306                         if (_ptr_driver_path) {
10307                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10309                         } else {
10310                                 r->driver_path = NULL;
10311                         }
10312                         ndr->flags = _flags_save_string;
10313                 }
10314                 {
10315                         uint32_t _flags_save_string = ndr->flags;
10316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10318                         if (_ptr_data_file) {
10319                                 NDR_PULL_ALLOC(ndr, r->data_file);
10320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10321                         } else {
10322                                 r->data_file = NULL;
10323                         }
10324                         ndr->flags = _flags_save_string;
10325                 }
10326                 {
10327                         uint32_t _flags_save_string = ndr->flags;
10328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10330                         if (_ptr_config_file) {
10331                                 NDR_PULL_ALLOC(ndr, r->config_file);
10332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10333                         } else {
10334                                 r->config_file = NULL;
10335                         }
10336                         ndr->flags = _flags_save_string;
10337                 }
10338                 {
10339                         uint32_t _flags_save_string = ndr->flags;
10340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10342                         if (_ptr_help_file) {
10343                                 NDR_PULL_ALLOC(ndr, r->help_file);
10344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10345                         } else {
10346                                 r->help_file = NULL;
10347                         }
10348                         ndr->flags = _flags_save_string;
10349                 }
10350                 {
10351                         uint32_t _flags_save_string_array = ndr->flags;
10352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10354                         if (_ptr_dependent_files) {
10355                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10357                         } else {
10358                                 r->dependent_files = NULL;
10359                         }
10360                         ndr->flags = _flags_save_string_array;
10361                 }
10362                 {
10363                         uint32_t _flags_save_string = ndr->flags;
10364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10366                         if (_ptr_monitor_name) {
10367                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10369                         } else {
10370                                 r->monitor_name = NULL;
10371                         }
10372                         ndr->flags = _flags_save_string;
10373                 }
10374                 {
10375                         uint32_t _flags_save_string = ndr->flags;
10376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10377                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10378                         if (_ptr_default_datatype) {
10379                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10380                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10381                         } else {
10382                                 r->default_datatype = NULL;
10383                         }
10384                         ndr->flags = _flags_save_string;
10385                 }
10386         }
10387         if (ndr_flags & NDR_BUFFERS) {
10388                 {
10389                         uint32_t _flags_save_string = ndr->flags;
10390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10391                         if (r->driver_name) {
10392                                 uint32_t _relative_save_offset;
10393                                 _relative_save_offset = ndr->offset;
10394                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10395                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10396                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10397                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10398                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10399                                 ndr->offset = _relative_save_offset;
10400                         }
10401                         ndr->flags = _flags_save_string;
10402                 }
10403                 {
10404                         uint32_t _flags_save_string = ndr->flags;
10405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10406                         if (r->architecture) {
10407                                 uint32_t _relative_save_offset;
10408                                 _relative_save_offset = ndr->offset;
10409                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10410                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10411                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10412                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10413                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10414                                 ndr->offset = _relative_save_offset;
10415                         }
10416                         ndr->flags = _flags_save_string;
10417                 }
10418                 {
10419                         uint32_t _flags_save_string = ndr->flags;
10420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10421                         if (r->driver_path) {
10422                                 uint32_t _relative_save_offset;
10423                                 _relative_save_offset = ndr->offset;
10424                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10425                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10426                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10427                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10428                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10429                                 ndr->offset = _relative_save_offset;
10430                         }
10431                         ndr->flags = _flags_save_string;
10432                 }
10433                 {
10434                         uint32_t _flags_save_string = ndr->flags;
10435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10436                         if (r->data_file) {
10437                                 uint32_t _relative_save_offset;
10438                                 _relative_save_offset = ndr->offset;
10439                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10440                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10441                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10442                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10443                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10444                                 ndr->offset = _relative_save_offset;
10445                         }
10446                         ndr->flags = _flags_save_string;
10447                 }
10448                 {
10449                         uint32_t _flags_save_string = ndr->flags;
10450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10451                         if (r->config_file) {
10452                                 uint32_t _relative_save_offset;
10453                                 _relative_save_offset = ndr->offset;
10454                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10455                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10456                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10457                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10458                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10459                                 ndr->offset = _relative_save_offset;
10460                         }
10461                         ndr->flags = _flags_save_string;
10462                 }
10463                 {
10464                         uint32_t _flags_save_string = ndr->flags;
10465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10466                         if (r->help_file) {
10467                                 uint32_t _relative_save_offset;
10468                                 _relative_save_offset = ndr->offset;
10469                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10470                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10471                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10472                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10473                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10474                                 ndr->offset = _relative_save_offset;
10475                         }
10476                         ndr->flags = _flags_save_string;
10477                 }
10478                 {
10479                         uint32_t _flags_save_string_array = ndr->flags;
10480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10481                         if (r->dependent_files) {
10482                                 uint32_t _relative_save_offset;
10483                                 _relative_save_offset = ndr->offset;
10484                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10485                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10486                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10487                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10488                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10489                                 ndr->offset = _relative_save_offset;
10490                         }
10491                         ndr->flags = _flags_save_string_array;
10492                 }
10493                 {
10494                         uint32_t _flags_save_string = ndr->flags;
10495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10496                         if (r->monitor_name) {
10497                                 uint32_t _relative_save_offset;
10498                                 _relative_save_offset = ndr->offset;
10499                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10500                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10501                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10502                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10503                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10504                                 ndr->offset = _relative_save_offset;
10505                         }
10506                         ndr->flags = _flags_save_string;
10507                 }
10508                 {
10509                         uint32_t _flags_save_string = ndr->flags;
10510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10511                         if (r->default_datatype) {
10512                                 uint32_t _relative_save_offset;
10513                                 _relative_save_offset = ndr->offset;
10514                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10515                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10516                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10517                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10518                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10519                                 ndr->offset = _relative_save_offset;
10520                         }
10521                         ndr->flags = _flags_save_string;
10522                 }
10523         }
10524         return NDR_ERR_SUCCESS;
10525 }
10526
10527 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10528 {
10529         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10530         ndr->depth++;
10531         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10532         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10533         ndr->depth++;
10534         if (r->driver_name) {
10535                 ndr_print_string(ndr, "driver_name", r->driver_name);
10536         }
10537         ndr->depth--;
10538         ndr_print_ptr(ndr, "architecture", r->architecture);
10539         ndr->depth++;
10540         if (r->architecture) {
10541                 ndr_print_string(ndr, "architecture", r->architecture);
10542         }
10543         ndr->depth--;
10544         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10545         ndr->depth++;
10546         if (r->driver_path) {
10547                 ndr_print_string(ndr, "driver_path", r->driver_path);
10548         }
10549         ndr->depth--;
10550         ndr_print_ptr(ndr, "data_file", r->data_file);
10551         ndr->depth++;
10552         if (r->data_file) {
10553                 ndr_print_string(ndr, "data_file", r->data_file);
10554         }
10555         ndr->depth--;
10556         ndr_print_ptr(ndr, "config_file", r->config_file);
10557         ndr->depth++;
10558         if (r->config_file) {
10559                 ndr_print_string(ndr, "config_file", r->config_file);
10560         }
10561         ndr->depth--;
10562         ndr_print_ptr(ndr, "help_file", r->help_file);
10563         ndr->depth++;
10564         if (r->help_file) {
10565                 ndr_print_string(ndr, "help_file", r->help_file);
10566         }
10567         ndr->depth--;
10568         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10569         ndr->depth++;
10570         if (r->dependent_files) {
10571                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10572         }
10573         ndr->depth--;
10574         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10575         ndr->depth++;
10576         if (r->monitor_name) {
10577                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10578         }
10579         ndr->depth--;
10580         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10581         ndr->depth++;
10582         if (r->default_datatype) {
10583                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10584         }
10585         ndr->depth--;
10586         ndr->depth--;
10587 }
10588
10589 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10590 {
10591         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10592 }
10593
10594 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10595 {
10596         if (ndr_flags & NDR_SCALARS) {
10597                 NDR_CHECK(ndr_push_align(ndr, 4));
10598                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10599                 {
10600                         uint32_t _flags_save_string = ndr->flags;
10601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10602                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10603                         ndr->flags = _flags_save_string;
10604                 }
10605                 {
10606                         uint32_t _flags_save_string = ndr->flags;
10607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10608                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10609                         ndr->flags = _flags_save_string;
10610                 }
10611                 {
10612                         uint32_t _flags_save_string = ndr->flags;
10613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10614                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10615                         ndr->flags = _flags_save_string;
10616                 }
10617                 {
10618                         uint32_t _flags_save_string = ndr->flags;
10619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10620                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10621                         ndr->flags = _flags_save_string;
10622                 }
10623                 {
10624                         uint32_t _flags_save_string = ndr->flags;
10625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10626                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10627                         ndr->flags = _flags_save_string;
10628                 }
10629                 {
10630                         uint32_t _flags_save_string = ndr->flags;
10631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10632                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10633                         ndr->flags = _flags_save_string;
10634                 }
10635                 {
10636                         uint32_t _flags_save_string_array = ndr->flags;
10637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10638                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10639                         ndr->flags = _flags_save_string_array;
10640                 }
10641                 {
10642                         uint32_t _flags_save_string = ndr->flags;
10643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10644                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10645                         ndr->flags = _flags_save_string;
10646                 }
10647                 {
10648                         uint32_t _flags_save_string = ndr->flags;
10649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10650                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10651                         ndr->flags = _flags_save_string;
10652                 }
10653                 {
10654                         uint32_t _flags_save_string_array = ndr->flags;
10655                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10656                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10657                         ndr->flags = _flags_save_string_array;
10658                 }
10659         }
10660         if (ndr_flags & NDR_BUFFERS) {
10661                 {
10662                         uint32_t _flags_save_string = ndr->flags;
10663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10664                         if (r->driver_name) {
10665                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10666                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10667                         }
10668                         ndr->flags = _flags_save_string;
10669                 }
10670                 {
10671                         uint32_t _flags_save_string = ndr->flags;
10672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10673                         if (r->architecture) {
10674                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10675                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10676                         }
10677                         ndr->flags = _flags_save_string;
10678                 }
10679                 {
10680                         uint32_t _flags_save_string = ndr->flags;
10681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10682                         if (r->driver_path) {
10683                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10684                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10685                         }
10686                         ndr->flags = _flags_save_string;
10687                 }
10688                 {
10689                         uint32_t _flags_save_string = ndr->flags;
10690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10691                         if (r->data_file) {
10692                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10693                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10694                         }
10695                         ndr->flags = _flags_save_string;
10696                 }
10697                 {
10698                         uint32_t _flags_save_string = ndr->flags;
10699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10700                         if (r->config_file) {
10701                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10702                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10703                         }
10704                         ndr->flags = _flags_save_string;
10705                 }
10706                 {
10707                         uint32_t _flags_save_string = ndr->flags;
10708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10709                         if (r->help_file) {
10710                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10711                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10712                         }
10713                         ndr->flags = _flags_save_string;
10714                 }
10715                 {
10716                         uint32_t _flags_save_string_array = ndr->flags;
10717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10718                         if (r->dependent_files) {
10719                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10720                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10721                         }
10722                         ndr->flags = _flags_save_string_array;
10723                 }
10724                 {
10725                         uint32_t _flags_save_string = ndr->flags;
10726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10727                         if (r->monitor_name) {
10728                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10730                         }
10731                         ndr->flags = _flags_save_string;
10732                 }
10733                 {
10734                         uint32_t _flags_save_string = ndr->flags;
10735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10736                         if (r->default_datatype) {
10737                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10738                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10739                         }
10740                         ndr->flags = _flags_save_string;
10741                 }
10742                 {
10743                         uint32_t _flags_save_string_array = ndr->flags;
10744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10745                         if (r->previous_names) {
10746                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10747                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10748                         }
10749                         ndr->flags = _flags_save_string_array;
10750                 }
10751         }
10752         return NDR_ERR_SUCCESS;
10753 }
10754
10755 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10756 {
10757         uint32_t _ptr_driver_name;
10758         TALLOC_CTX *_mem_save_driver_name_0;
10759         uint32_t _ptr_architecture;
10760         TALLOC_CTX *_mem_save_architecture_0;
10761         uint32_t _ptr_driver_path;
10762         TALLOC_CTX *_mem_save_driver_path_0;
10763         uint32_t _ptr_data_file;
10764         TALLOC_CTX *_mem_save_data_file_0;
10765         uint32_t _ptr_config_file;
10766         TALLOC_CTX *_mem_save_config_file_0;
10767         uint32_t _ptr_help_file;
10768         TALLOC_CTX *_mem_save_help_file_0;
10769         uint32_t _ptr_dependent_files;
10770         TALLOC_CTX *_mem_save_dependent_files_0;
10771         uint32_t _ptr_monitor_name;
10772         TALLOC_CTX *_mem_save_monitor_name_0;
10773         uint32_t _ptr_default_datatype;
10774         TALLOC_CTX *_mem_save_default_datatype_0;
10775         uint32_t _ptr_previous_names;
10776         TALLOC_CTX *_mem_save_previous_names_0;
10777         if (ndr_flags & NDR_SCALARS) {
10778                 NDR_CHECK(ndr_pull_align(ndr, 4));
10779                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10780                 {
10781                         uint32_t _flags_save_string = ndr->flags;
10782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10783                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10784                         if (_ptr_driver_name) {
10785                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10786                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10787                         } else {
10788                                 r->driver_name = NULL;
10789                         }
10790                         ndr->flags = _flags_save_string;
10791                 }
10792                 {
10793                         uint32_t _flags_save_string = ndr->flags;
10794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10795                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10796                         if (_ptr_architecture) {
10797                                 NDR_PULL_ALLOC(ndr, r->architecture);
10798                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10799                         } else {
10800                                 r->architecture = NULL;
10801                         }
10802                         ndr->flags = _flags_save_string;
10803                 }
10804                 {
10805                         uint32_t _flags_save_string = ndr->flags;
10806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10807                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10808                         if (_ptr_driver_path) {
10809                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10810                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10811                         } else {
10812                                 r->driver_path = NULL;
10813                         }
10814                         ndr->flags = _flags_save_string;
10815                 }
10816                 {
10817                         uint32_t _flags_save_string = ndr->flags;
10818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10819                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10820                         if (_ptr_data_file) {
10821                                 NDR_PULL_ALLOC(ndr, r->data_file);
10822                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10823                         } else {
10824                                 r->data_file = NULL;
10825                         }
10826                         ndr->flags = _flags_save_string;
10827                 }
10828                 {
10829                         uint32_t _flags_save_string = ndr->flags;
10830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10832                         if (_ptr_config_file) {
10833                                 NDR_PULL_ALLOC(ndr, r->config_file);
10834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10835                         } else {
10836                                 r->config_file = NULL;
10837                         }
10838                         ndr->flags = _flags_save_string;
10839                 }
10840                 {
10841                         uint32_t _flags_save_string = ndr->flags;
10842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10843                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10844                         if (_ptr_help_file) {
10845                                 NDR_PULL_ALLOC(ndr, r->help_file);
10846                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10847                         } else {
10848                                 r->help_file = NULL;
10849                         }
10850                         ndr->flags = _flags_save_string;
10851                 }
10852                 {
10853                         uint32_t _flags_save_string_array = ndr->flags;
10854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10856                         if (_ptr_dependent_files) {
10857                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10859                         } else {
10860                                 r->dependent_files = NULL;
10861                         }
10862                         ndr->flags = _flags_save_string_array;
10863                 }
10864                 {
10865                         uint32_t _flags_save_string = ndr->flags;
10866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10867                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10868                         if (_ptr_monitor_name) {
10869                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10870                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10871                         } else {
10872                                 r->monitor_name = NULL;
10873                         }
10874                         ndr->flags = _flags_save_string;
10875                 }
10876                 {
10877                         uint32_t _flags_save_string = ndr->flags;
10878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10879                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10880                         if (_ptr_default_datatype) {
10881                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10882                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10883                         } else {
10884                                 r->default_datatype = NULL;
10885                         }
10886                         ndr->flags = _flags_save_string;
10887                 }
10888                 {
10889                         uint32_t _flags_save_string_array = ndr->flags;
10890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10891                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10892                         if (_ptr_previous_names) {
10893                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10894                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10895                         } else {
10896                                 r->previous_names = NULL;
10897                         }
10898                         ndr->flags = _flags_save_string_array;
10899                 }
10900         }
10901         if (ndr_flags & NDR_BUFFERS) {
10902                 {
10903                         uint32_t _flags_save_string = ndr->flags;
10904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10905                         if (r->driver_name) {
10906                                 uint32_t _relative_save_offset;
10907                                 _relative_save_offset = ndr->offset;
10908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10909                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10910                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10913                                 ndr->offset = _relative_save_offset;
10914                         }
10915                         ndr->flags = _flags_save_string;
10916                 }
10917                 {
10918                         uint32_t _flags_save_string = ndr->flags;
10919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10920                         if (r->architecture) {
10921                                 uint32_t _relative_save_offset;
10922                                 _relative_save_offset = ndr->offset;
10923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10924                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10925                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10928                                 ndr->offset = _relative_save_offset;
10929                         }
10930                         ndr->flags = _flags_save_string;
10931                 }
10932                 {
10933                         uint32_t _flags_save_string = ndr->flags;
10934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10935                         if (r->driver_path) {
10936                                 uint32_t _relative_save_offset;
10937                                 _relative_save_offset = ndr->offset;
10938                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10939                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10940                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10941                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10942                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10943                                 ndr->offset = _relative_save_offset;
10944                         }
10945                         ndr->flags = _flags_save_string;
10946                 }
10947                 {
10948                         uint32_t _flags_save_string = ndr->flags;
10949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10950                         if (r->data_file) {
10951                                 uint32_t _relative_save_offset;
10952                                 _relative_save_offset = ndr->offset;
10953                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10954                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10955                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10956                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10957                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10958                                 ndr->offset = _relative_save_offset;
10959                         }
10960                         ndr->flags = _flags_save_string;
10961                 }
10962                 {
10963                         uint32_t _flags_save_string = ndr->flags;
10964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10965                         if (r->config_file) {
10966                                 uint32_t _relative_save_offset;
10967                                 _relative_save_offset = ndr->offset;
10968                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10969                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10970                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10971                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10972                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10973                                 ndr->offset = _relative_save_offset;
10974                         }
10975                         ndr->flags = _flags_save_string;
10976                 }
10977                 {
10978                         uint32_t _flags_save_string = ndr->flags;
10979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10980                         if (r->help_file) {
10981                                 uint32_t _relative_save_offset;
10982                                 _relative_save_offset = ndr->offset;
10983                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10984                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10985                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10986                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10987                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10988                                 ndr->offset = _relative_save_offset;
10989                         }
10990                         ndr->flags = _flags_save_string;
10991                 }
10992                 {
10993                         uint32_t _flags_save_string_array = ndr->flags;
10994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10995                         if (r->dependent_files) {
10996                                 uint32_t _relative_save_offset;
10997                                 _relative_save_offset = ndr->offset;
10998                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10999                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11000                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11001                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11002                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11003                                 ndr->offset = _relative_save_offset;
11004                         }
11005                         ndr->flags = _flags_save_string_array;
11006                 }
11007                 {
11008                         uint32_t _flags_save_string = ndr->flags;
11009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11010                         if (r->monitor_name) {
11011                                 uint32_t _relative_save_offset;
11012                                 _relative_save_offset = ndr->offset;
11013                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11014                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11015                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11016                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11017                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11018                                 ndr->offset = _relative_save_offset;
11019                         }
11020                         ndr->flags = _flags_save_string;
11021                 }
11022                 {
11023                         uint32_t _flags_save_string = ndr->flags;
11024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11025                         if (r->default_datatype) {
11026                                 uint32_t _relative_save_offset;
11027                                 _relative_save_offset = ndr->offset;
11028                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11029                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11030                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11031                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11032                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11033                                 ndr->offset = _relative_save_offset;
11034                         }
11035                         ndr->flags = _flags_save_string;
11036                 }
11037                 {
11038                         uint32_t _flags_save_string_array = ndr->flags;
11039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11040                         if (r->previous_names) {
11041                                 uint32_t _relative_save_offset;
11042                                 _relative_save_offset = ndr->offset;
11043                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11044                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11045                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11046                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11047                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11048                                 ndr->offset = _relative_save_offset;
11049                         }
11050                         ndr->flags = _flags_save_string_array;
11051                 }
11052         }
11053         return NDR_ERR_SUCCESS;
11054 }
11055
11056 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11057 {
11058         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11059         ndr->depth++;
11060         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11061         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11062         ndr->depth++;
11063         if (r->driver_name) {
11064                 ndr_print_string(ndr, "driver_name", r->driver_name);
11065         }
11066         ndr->depth--;
11067         ndr_print_ptr(ndr, "architecture", r->architecture);
11068         ndr->depth++;
11069         if (r->architecture) {
11070                 ndr_print_string(ndr, "architecture", r->architecture);
11071         }
11072         ndr->depth--;
11073         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11074         ndr->depth++;
11075         if (r->driver_path) {
11076                 ndr_print_string(ndr, "driver_path", r->driver_path);
11077         }
11078         ndr->depth--;
11079         ndr_print_ptr(ndr, "data_file", r->data_file);
11080         ndr->depth++;
11081         if (r->data_file) {
11082                 ndr_print_string(ndr, "data_file", r->data_file);
11083         }
11084         ndr->depth--;
11085         ndr_print_ptr(ndr, "config_file", r->config_file);
11086         ndr->depth++;
11087         if (r->config_file) {
11088                 ndr_print_string(ndr, "config_file", r->config_file);
11089         }
11090         ndr->depth--;
11091         ndr_print_ptr(ndr, "help_file", r->help_file);
11092         ndr->depth++;
11093         if (r->help_file) {
11094                 ndr_print_string(ndr, "help_file", r->help_file);
11095         }
11096         ndr->depth--;
11097         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11098         ndr->depth++;
11099         if (r->dependent_files) {
11100                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11101         }
11102         ndr->depth--;
11103         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11104         ndr->depth++;
11105         if (r->monitor_name) {
11106                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11107         }
11108         ndr->depth--;
11109         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11110         ndr->depth++;
11111         if (r->default_datatype) {
11112                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11113         }
11114         ndr->depth--;
11115         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11116         ndr->depth++;
11117         if (r->previous_names) {
11118                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11119         }
11120         ndr->depth--;
11121         ndr->depth--;
11122 }
11123
11124 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11125 {
11126         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11127 }
11128
11129 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11130 {
11131         if (ndr_flags & NDR_SCALARS) {
11132                 NDR_CHECK(ndr_push_align(ndr, 4));
11133                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11134                 {
11135                         uint32_t _flags_save_string = ndr->flags;
11136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11137                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11138                         ndr->flags = _flags_save_string;
11139                 }
11140                 {
11141                         uint32_t _flags_save_string = ndr->flags;
11142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11143                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11144                         ndr->flags = _flags_save_string;
11145                 }
11146                 {
11147                         uint32_t _flags_save_string = ndr->flags;
11148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11149                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11150                         ndr->flags = _flags_save_string;
11151                 }
11152                 {
11153                         uint32_t _flags_save_string = ndr->flags;
11154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11155                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11156                         ndr->flags = _flags_save_string;
11157                 }
11158                 {
11159                         uint32_t _flags_save_string = ndr->flags;
11160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11161                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11162                         ndr->flags = _flags_save_string;
11163                 }
11164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
11165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11167         }
11168         if (ndr_flags & NDR_BUFFERS) {
11169                 {
11170                         uint32_t _flags_save_string = ndr->flags;
11171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11172                         if (r->driver_name) {
11173                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11174                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11175                         }
11176                         ndr->flags = _flags_save_string;
11177                 }
11178                 {
11179                         uint32_t _flags_save_string = ndr->flags;
11180                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11181                         if (r->architecture) {
11182                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11183                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11184                         }
11185                         ndr->flags = _flags_save_string;
11186                 }
11187                 {
11188                         uint32_t _flags_save_string = ndr->flags;
11189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11190                         if (r->driver_path) {
11191                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11192                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11193                         }
11194                         ndr->flags = _flags_save_string;
11195                 }
11196                 {
11197                         uint32_t _flags_save_string = ndr->flags;
11198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11199                         if (r->data_file) {
11200                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11201                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11202                         }
11203                         ndr->flags = _flags_save_string;
11204                 }
11205                 {
11206                         uint32_t _flags_save_string = ndr->flags;
11207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11208                         if (r->config_file) {
11209                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11210                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11211                         }
11212                         ndr->flags = _flags_save_string;
11213                 }
11214         }
11215         return NDR_ERR_SUCCESS;
11216 }
11217
11218 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11219 {
11220         uint32_t _ptr_driver_name;
11221         TALLOC_CTX *_mem_save_driver_name_0;
11222         uint32_t _ptr_architecture;
11223         TALLOC_CTX *_mem_save_architecture_0;
11224         uint32_t _ptr_driver_path;
11225         TALLOC_CTX *_mem_save_driver_path_0;
11226         uint32_t _ptr_data_file;
11227         TALLOC_CTX *_mem_save_data_file_0;
11228         uint32_t _ptr_config_file;
11229         TALLOC_CTX *_mem_save_config_file_0;
11230         if (ndr_flags & NDR_SCALARS) {
11231                 NDR_CHECK(ndr_pull_align(ndr, 4));
11232                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11233                 {
11234                         uint32_t _flags_save_string = ndr->flags;
11235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11237                         if (_ptr_driver_name) {
11238                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11240                         } else {
11241                                 r->driver_name = NULL;
11242                         }
11243                         ndr->flags = _flags_save_string;
11244                 }
11245                 {
11246                         uint32_t _flags_save_string = ndr->flags;
11247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11248                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11249                         if (_ptr_architecture) {
11250                                 NDR_PULL_ALLOC(ndr, r->architecture);
11251                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11252                         } else {
11253                                 r->architecture = NULL;
11254                         }
11255                         ndr->flags = _flags_save_string;
11256                 }
11257                 {
11258                         uint32_t _flags_save_string = ndr->flags;
11259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11260                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11261                         if (_ptr_driver_path) {
11262                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11263                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11264                         } else {
11265                                 r->driver_path = NULL;
11266                         }
11267                         ndr->flags = _flags_save_string;
11268                 }
11269                 {
11270                         uint32_t _flags_save_string = ndr->flags;
11271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11273                         if (_ptr_data_file) {
11274                                 NDR_PULL_ALLOC(ndr, r->data_file);
11275                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11276                         } else {
11277                                 r->data_file = NULL;
11278                         }
11279                         ndr->flags = _flags_save_string;
11280                 }
11281                 {
11282                         uint32_t _flags_save_string = ndr->flags;
11283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11284                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11285                         if (_ptr_config_file) {
11286                                 NDR_PULL_ALLOC(ndr, r->config_file);
11287                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11288                         } else {
11289                                 r->config_file = NULL;
11290                         }
11291                         ndr->flags = _flags_save_string;
11292                 }
11293                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
11294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11296         }
11297         if (ndr_flags & NDR_BUFFERS) {
11298                 {
11299                         uint32_t _flags_save_string = ndr->flags;
11300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11301                         if (r->driver_name) {
11302                                 uint32_t _relative_save_offset;
11303                                 _relative_save_offset = ndr->offset;
11304                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11305                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11306                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11307                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11308                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11309                                 ndr->offset = _relative_save_offset;
11310                         }
11311                         ndr->flags = _flags_save_string;
11312                 }
11313                 {
11314                         uint32_t _flags_save_string = ndr->flags;
11315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11316                         if (r->architecture) {
11317                                 uint32_t _relative_save_offset;
11318                                 _relative_save_offset = ndr->offset;
11319                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11320                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11321                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11322                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11323                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11324                                 ndr->offset = _relative_save_offset;
11325                         }
11326                         ndr->flags = _flags_save_string;
11327                 }
11328                 {
11329                         uint32_t _flags_save_string = ndr->flags;
11330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11331                         if (r->driver_path) {
11332                                 uint32_t _relative_save_offset;
11333                                 _relative_save_offset = ndr->offset;
11334                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11335                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11336                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11337                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11338                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11339                                 ndr->offset = _relative_save_offset;
11340                         }
11341                         ndr->flags = _flags_save_string;
11342                 }
11343                 {
11344                         uint32_t _flags_save_string = ndr->flags;
11345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11346                         if (r->data_file) {
11347                                 uint32_t _relative_save_offset;
11348                                 _relative_save_offset = ndr->offset;
11349                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11350                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11351                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11352                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11353                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11354                                 ndr->offset = _relative_save_offset;
11355                         }
11356                         ndr->flags = _flags_save_string;
11357                 }
11358                 {
11359                         uint32_t _flags_save_string = ndr->flags;
11360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11361                         if (r->config_file) {
11362                                 uint32_t _relative_save_offset;
11363                                 _relative_save_offset = ndr->offset;
11364                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11365                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11366                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11367                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11368                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11369                                 ndr->offset = _relative_save_offset;
11370                         }
11371                         ndr->flags = _flags_save_string;
11372                 }
11373         }
11374         return NDR_ERR_SUCCESS;
11375 }
11376
11377 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11378 {
11379         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11380         ndr->depth++;
11381         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11382         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11383         ndr->depth++;
11384         if (r->driver_name) {
11385                 ndr_print_string(ndr, "driver_name", r->driver_name);
11386         }
11387         ndr->depth--;
11388         ndr_print_ptr(ndr, "architecture", r->architecture);
11389         ndr->depth++;
11390         if (r->architecture) {
11391                 ndr_print_string(ndr, "architecture", r->architecture);
11392         }
11393         ndr->depth--;
11394         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11395         ndr->depth++;
11396         if (r->driver_path) {
11397                 ndr_print_string(ndr, "driver_path", r->driver_path);
11398         }
11399         ndr->depth--;
11400         ndr_print_ptr(ndr, "data_file", r->data_file);
11401         ndr->depth++;
11402         if (r->data_file) {
11403                 ndr_print_string(ndr, "data_file", r->data_file);
11404         }
11405         ndr->depth--;
11406         ndr_print_ptr(ndr, "config_file", r->config_file);
11407         ndr->depth++;
11408         if (r->config_file) {
11409                 ndr_print_string(ndr, "config_file", r->config_file);
11410         }
11411         ndr->depth--;
11412         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
11413         ndr_print_uint32(ndr, "config_version", r->config_version);
11414         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11415         ndr->depth--;
11416 }
11417
11418 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11419 {
11420         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11421 }
11422
11423 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11424 {
11425         if (ndr_flags & NDR_SCALARS) {
11426                 NDR_CHECK(ndr_push_align(ndr, 8));
11427                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11428                 {
11429                         uint32_t _flags_save_string = ndr->flags;
11430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11431                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11432                         ndr->flags = _flags_save_string;
11433                 }
11434                 {
11435                         uint32_t _flags_save_string = ndr->flags;
11436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11437                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11438                         ndr->flags = _flags_save_string;
11439                 }
11440                 {
11441                         uint32_t _flags_save_string = ndr->flags;
11442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11443                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11444                         ndr->flags = _flags_save_string;
11445                 }
11446                 {
11447                         uint32_t _flags_save_string = ndr->flags;
11448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11449                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11450                         ndr->flags = _flags_save_string;
11451                 }
11452                 {
11453                         uint32_t _flags_save_string = ndr->flags;
11454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11455                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11456                         ndr->flags = _flags_save_string;
11457                 }
11458                 {
11459                         uint32_t _flags_save_string = ndr->flags;
11460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11461                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11462                         ndr->flags = _flags_save_string;
11463                 }
11464                 {
11465                         uint32_t _flags_save_string_array = ndr->flags;
11466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11467                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11468                         ndr->flags = _flags_save_string_array;
11469                 }
11470                 {
11471                         uint32_t _flags_save_string = ndr->flags;
11472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11473                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11474                         ndr->flags = _flags_save_string;
11475                 }
11476                 {
11477                         uint32_t _flags_save_string = ndr->flags;
11478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11479                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11480                         ndr->flags = _flags_save_string;
11481                 }
11482                 {
11483                         uint32_t _flags_save_string_array = ndr->flags;
11484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11485                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11486                         ndr->flags = _flags_save_string_array;
11487                 }
11488                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11489                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11490                 {
11491                         uint32_t _flags_save_string = ndr->flags;
11492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11493                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11494                         ndr->flags = _flags_save_string;
11495                 }
11496                 {
11497                         uint32_t _flags_save_string = ndr->flags;
11498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11499                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11500                         ndr->flags = _flags_save_string;
11501                 }
11502                 {
11503                         uint32_t _flags_save_string = ndr->flags;
11504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11505                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11506                         ndr->flags = _flags_save_string;
11507                 }
11508                 {
11509                         uint32_t _flags_save_string = ndr->flags;
11510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11511                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11512                         ndr->flags = _flags_save_string;
11513                 }
11514         }
11515         if (ndr_flags & NDR_BUFFERS) {
11516                 {
11517                         uint32_t _flags_save_string = ndr->flags;
11518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11519                         if (r->driver_name) {
11520                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11521                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11522                         }
11523                         ndr->flags = _flags_save_string;
11524                 }
11525                 {
11526                         uint32_t _flags_save_string = ndr->flags;
11527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11528                         if (r->architecture) {
11529                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11530                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11531                         }
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         if (r->driver_path) {
11538                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11539                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11540                         }
11541                         ndr->flags = _flags_save_string;
11542                 }
11543                 {
11544                         uint32_t _flags_save_string = ndr->flags;
11545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11546                         if (r->data_file) {
11547                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11548                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11549                         }
11550                         ndr->flags = _flags_save_string;
11551                 }
11552                 {
11553                         uint32_t _flags_save_string = ndr->flags;
11554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11555                         if (r->config_file) {
11556                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11557                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11558                         }
11559                         ndr->flags = _flags_save_string;
11560                 }
11561                 {
11562                         uint32_t _flags_save_string = ndr->flags;
11563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11564                         if (r->help_file) {
11565                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11566                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11567                         }
11568                         ndr->flags = _flags_save_string;
11569                 }
11570                 {
11571                         uint32_t _flags_save_string_array = ndr->flags;
11572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11573                         if (r->dependent_files) {
11574                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11575                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11576                         }
11577                         ndr->flags = _flags_save_string_array;
11578                 }
11579                 {
11580                         uint32_t _flags_save_string = ndr->flags;
11581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11582                         if (r->monitor_name) {
11583                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11584                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11585                         }
11586                         ndr->flags = _flags_save_string;
11587                 }
11588                 {
11589                         uint32_t _flags_save_string = ndr->flags;
11590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11591                         if (r->default_datatype) {
11592                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11593                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11594                         }
11595                         ndr->flags = _flags_save_string;
11596                 }
11597                 {
11598                         uint32_t _flags_save_string_array = ndr->flags;
11599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11600                         if (r->previous_names) {
11601                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11602                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11603                         }
11604                         ndr->flags = _flags_save_string_array;
11605                 }
11606                 {
11607                         uint32_t _flags_save_string = ndr->flags;
11608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11609                         if (r->manufacturer_name) {
11610                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11611                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11612                         }
11613                         ndr->flags = _flags_save_string;
11614                 }
11615                 {
11616                         uint32_t _flags_save_string = ndr->flags;
11617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11618                         if (r->manufacturer_url) {
11619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11621                         }
11622                         ndr->flags = _flags_save_string;
11623                 }
11624                 {
11625                         uint32_t _flags_save_string = ndr->flags;
11626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11627                         if (r->hardware_id) {
11628                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11630                         }
11631                         ndr->flags = _flags_save_string;
11632                 }
11633                 {
11634                         uint32_t _flags_save_string = ndr->flags;
11635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11636                         if (r->provider) {
11637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11639                         }
11640                         ndr->flags = _flags_save_string;
11641                 }
11642         }
11643         return NDR_ERR_SUCCESS;
11644 }
11645
11646 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11647 {
11648         uint32_t _ptr_driver_name;
11649         TALLOC_CTX *_mem_save_driver_name_0;
11650         uint32_t _ptr_architecture;
11651         TALLOC_CTX *_mem_save_architecture_0;
11652         uint32_t _ptr_driver_path;
11653         TALLOC_CTX *_mem_save_driver_path_0;
11654         uint32_t _ptr_data_file;
11655         TALLOC_CTX *_mem_save_data_file_0;
11656         uint32_t _ptr_config_file;
11657         TALLOC_CTX *_mem_save_config_file_0;
11658         uint32_t _ptr_help_file;
11659         TALLOC_CTX *_mem_save_help_file_0;
11660         uint32_t _ptr_dependent_files;
11661         TALLOC_CTX *_mem_save_dependent_files_0;
11662         uint32_t _ptr_monitor_name;
11663         TALLOC_CTX *_mem_save_monitor_name_0;
11664         uint32_t _ptr_default_datatype;
11665         TALLOC_CTX *_mem_save_default_datatype_0;
11666         uint32_t _ptr_previous_names;
11667         TALLOC_CTX *_mem_save_previous_names_0;
11668         uint32_t _ptr_manufacturer_name;
11669         TALLOC_CTX *_mem_save_manufacturer_name_0;
11670         uint32_t _ptr_manufacturer_url;
11671         TALLOC_CTX *_mem_save_manufacturer_url_0;
11672         uint32_t _ptr_hardware_id;
11673         TALLOC_CTX *_mem_save_hardware_id_0;
11674         uint32_t _ptr_provider;
11675         TALLOC_CTX *_mem_save_provider_0;
11676         if (ndr_flags & NDR_SCALARS) {
11677                 NDR_CHECK(ndr_pull_align(ndr, 8));
11678                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11679                 {
11680                         uint32_t _flags_save_string = ndr->flags;
11681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11682                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11683                         if (_ptr_driver_name) {
11684                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11685                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11686                         } else {
11687                                 r->driver_name = NULL;
11688                         }
11689                         ndr->flags = _flags_save_string;
11690                 }
11691                 {
11692                         uint32_t _flags_save_string = ndr->flags;
11693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11694                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11695                         if (_ptr_architecture) {
11696                                 NDR_PULL_ALLOC(ndr, r->architecture);
11697                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11698                         } else {
11699                                 r->architecture = NULL;
11700                         }
11701                         ndr->flags = _flags_save_string;
11702                 }
11703                 {
11704                         uint32_t _flags_save_string = ndr->flags;
11705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11706                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11707                         if (_ptr_driver_path) {
11708                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11709                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11710                         } else {
11711                                 r->driver_path = NULL;
11712                         }
11713                         ndr->flags = _flags_save_string;
11714                 }
11715                 {
11716                         uint32_t _flags_save_string = ndr->flags;
11717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11718                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11719                         if (_ptr_data_file) {
11720                                 NDR_PULL_ALLOC(ndr, r->data_file);
11721                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11722                         } else {
11723                                 r->data_file = NULL;
11724                         }
11725                         ndr->flags = _flags_save_string;
11726                 }
11727                 {
11728                         uint32_t _flags_save_string = ndr->flags;
11729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11730                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11731                         if (_ptr_config_file) {
11732                                 NDR_PULL_ALLOC(ndr, r->config_file);
11733                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11734                         } else {
11735                                 r->config_file = NULL;
11736                         }
11737                         ndr->flags = _flags_save_string;
11738                 }
11739                 {
11740                         uint32_t _flags_save_string = ndr->flags;
11741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11742                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11743                         if (_ptr_help_file) {
11744                                 NDR_PULL_ALLOC(ndr, r->help_file);
11745                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11746                         } else {
11747                                 r->help_file = NULL;
11748                         }
11749                         ndr->flags = _flags_save_string;
11750                 }
11751                 {
11752                         uint32_t _flags_save_string_array = ndr->flags;
11753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11754                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11755                         if (_ptr_dependent_files) {
11756                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11757                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11758                         } else {
11759                                 r->dependent_files = NULL;
11760                         }
11761                         ndr->flags = _flags_save_string_array;
11762                 }
11763                 {
11764                         uint32_t _flags_save_string = ndr->flags;
11765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11766                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11767                         if (_ptr_monitor_name) {
11768                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11769                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11770                         } else {
11771                                 r->monitor_name = NULL;
11772                         }
11773                         ndr->flags = _flags_save_string;
11774                 }
11775                 {
11776                         uint32_t _flags_save_string = ndr->flags;
11777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11778                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11779                         if (_ptr_default_datatype) {
11780                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11781                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11782                         } else {
11783                                 r->default_datatype = NULL;
11784                         }
11785                         ndr->flags = _flags_save_string;
11786                 }
11787                 {
11788                         uint32_t _flags_save_string_array = ndr->flags;
11789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11791                         if (_ptr_previous_names) {
11792                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11794                         } else {
11795                                 r->previous_names = NULL;
11796                         }
11797                         ndr->flags = _flags_save_string_array;
11798                 }
11799                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11800                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11801                 {
11802                         uint32_t _flags_save_string = ndr->flags;
11803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11804                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11805                         if (_ptr_manufacturer_name) {
11806                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11807                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11808                         } else {
11809                                 r->manufacturer_name = NULL;
11810                         }
11811                         ndr->flags = _flags_save_string;
11812                 }
11813                 {
11814                         uint32_t _flags_save_string = ndr->flags;
11815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11816                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11817                         if (_ptr_manufacturer_url) {
11818                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11819                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11820                         } else {
11821                                 r->manufacturer_url = NULL;
11822                         }
11823                         ndr->flags = _flags_save_string;
11824                 }
11825                 {
11826                         uint32_t _flags_save_string = ndr->flags;
11827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11828                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11829                         if (_ptr_hardware_id) {
11830                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11831                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11832                         } else {
11833                                 r->hardware_id = NULL;
11834                         }
11835                         ndr->flags = _flags_save_string;
11836                 }
11837                 {
11838                         uint32_t _flags_save_string = ndr->flags;
11839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11840                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11841                         if (_ptr_provider) {
11842                                 NDR_PULL_ALLOC(ndr, r->provider);
11843                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11844                         } else {
11845                                 r->provider = NULL;
11846                         }
11847                         ndr->flags = _flags_save_string;
11848                 }
11849         }
11850         if (ndr_flags & NDR_BUFFERS) {
11851                 {
11852                         uint32_t _flags_save_string = ndr->flags;
11853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11854                         if (r->driver_name) {
11855                                 uint32_t _relative_save_offset;
11856                                 _relative_save_offset = ndr->offset;
11857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11858                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11859                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11862                                 ndr->offset = _relative_save_offset;
11863                         }
11864                         ndr->flags = _flags_save_string;
11865                 }
11866                 {
11867                         uint32_t _flags_save_string = ndr->flags;
11868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11869                         if (r->architecture) {
11870                                 uint32_t _relative_save_offset;
11871                                 _relative_save_offset = ndr->offset;
11872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11873                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11874                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11877                                 ndr->offset = _relative_save_offset;
11878                         }
11879                         ndr->flags = _flags_save_string;
11880                 }
11881                 {
11882                         uint32_t _flags_save_string = ndr->flags;
11883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11884                         if (r->driver_path) {
11885                                 uint32_t _relative_save_offset;
11886                                 _relative_save_offset = ndr->offset;
11887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11888                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11889                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11892                                 ndr->offset = _relative_save_offset;
11893                         }
11894                         ndr->flags = _flags_save_string;
11895                 }
11896                 {
11897                         uint32_t _flags_save_string = ndr->flags;
11898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11899                         if (r->data_file) {
11900                                 uint32_t _relative_save_offset;
11901                                 _relative_save_offset = ndr->offset;
11902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11903                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11904                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11907                                 ndr->offset = _relative_save_offset;
11908                         }
11909                         ndr->flags = _flags_save_string;
11910                 }
11911                 {
11912                         uint32_t _flags_save_string = ndr->flags;
11913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11914                         if (r->config_file) {
11915                                 uint32_t _relative_save_offset;
11916                                 _relative_save_offset = ndr->offset;
11917                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11918                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11919                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11920                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11921                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11922                                 ndr->offset = _relative_save_offset;
11923                         }
11924                         ndr->flags = _flags_save_string;
11925                 }
11926                 {
11927                         uint32_t _flags_save_string = ndr->flags;
11928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11929                         if (r->help_file) {
11930                                 uint32_t _relative_save_offset;
11931                                 _relative_save_offset = ndr->offset;
11932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11933                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11934                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11937                                 ndr->offset = _relative_save_offset;
11938                         }
11939                         ndr->flags = _flags_save_string;
11940                 }
11941                 {
11942                         uint32_t _flags_save_string_array = ndr->flags;
11943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11944                         if (r->dependent_files) {
11945                                 uint32_t _relative_save_offset;
11946                                 _relative_save_offset = ndr->offset;
11947                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11948                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11949                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11950                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11951                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11952                                 ndr->offset = _relative_save_offset;
11953                         }
11954                         ndr->flags = _flags_save_string_array;
11955                 }
11956                 {
11957                         uint32_t _flags_save_string = ndr->flags;
11958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11959                         if (r->monitor_name) {
11960                                 uint32_t _relative_save_offset;
11961                                 _relative_save_offset = ndr->offset;
11962                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11963                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11964                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11965                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11966                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11967                                 ndr->offset = _relative_save_offset;
11968                         }
11969                         ndr->flags = _flags_save_string;
11970                 }
11971                 {
11972                         uint32_t _flags_save_string = ndr->flags;
11973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11974                         if (r->default_datatype) {
11975                                 uint32_t _relative_save_offset;
11976                                 _relative_save_offset = ndr->offset;
11977                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11978                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11979                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11980                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11981                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11982                                 ndr->offset = _relative_save_offset;
11983                         }
11984                         ndr->flags = _flags_save_string;
11985                 }
11986                 {
11987                         uint32_t _flags_save_string_array = ndr->flags;
11988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11989                         if (r->previous_names) {
11990                                 uint32_t _relative_save_offset;
11991                                 _relative_save_offset = ndr->offset;
11992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11993                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11994                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11995                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11997                                 ndr->offset = _relative_save_offset;
11998                         }
11999                         ndr->flags = _flags_save_string_array;
12000                 }
12001                 {
12002                         uint32_t _flags_save_string = ndr->flags;
12003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12004                         if (r->manufacturer_name) {
12005                                 uint32_t _relative_save_offset;
12006                                 _relative_save_offset = ndr->offset;
12007                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12008                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12009                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12010                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12011                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12012                                 ndr->offset = _relative_save_offset;
12013                         }
12014                         ndr->flags = _flags_save_string;
12015                 }
12016                 {
12017                         uint32_t _flags_save_string = ndr->flags;
12018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12019                         if (r->manufacturer_url) {
12020                                 uint32_t _relative_save_offset;
12021                                 _relative_save_offset = ndr->offset;
12022                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12023                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12024                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12025                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12026                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12027                                 ndr->offset = _relative_save_offset;
12028                         }
12029                         ndr->flags = _flags_save_string;
12030                 }
12031                 {
12032                         uint32_t _flags_save_string = ndr->flags;
12033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12034                         if (r->hardware_id) {
12035                                 uint32_t _relative_save_offset;
12036                                 _relative_save_offset = ndr->offset;
12037                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12038                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12039                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12040                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12041                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12042                                 ndr->offset = _relative_save_offset;
12043                         }
12044                         ndr->flags = _flags_save_string;
12045                 }
12046                 {
12047                         uint32_t _flags_save_string = ndr->flags;
12048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12049                         if (r->provider) {
12050                                 uint32_t _relative_save_offset;
12051                                 _relative_save_offset = ndr->offset;
12052                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12053                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12054                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12055                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12056                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12057                                 ndr->offset = _relative_save_offset;
12058                         }
12059                         ndr->flags = _flags_save_string;
12060                 }
12061         }
12062         return NDR_ERR_SUCCESS;
12063 }
12064
12065 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12066 {
12067         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12068         ndr->depth++;
12069         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12070         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12071         ndr->depth++;
12072         if (r->driver_name) {
12073                 ndr_print_string(ndr, "driver_name", r->driver_name);
12074         }
12075         ndr->depth--;
12076         ndr_print_ptr(ndr, "architecture", r->architecture);
12077         ndr->depth++;
12078         if (r->architecture) {
12079                 ndr_print_string(ndr, "architecture", r->architecture);
12080         }
12081         ndr->depth--;
12082         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12083         ndr->depth++;
12084         if (r->driver_path) {
12085                 ndr_print_string(ndr, "driver_path", r->driver_path);
12086         }
12087         ndr->depth--;
12088         ndr_print_ptr(ndr, "data_file", r->data_file);
12089         ndr->depth++;
12090         if (r->data_file) {
12091                 ndr_print_string(ndr, "data_file", r->data_file);
12092         }
12093         ndr->depth--;
12094         ndr_print_ptr(ndr, "config_file", r->config_file);
12095         ndr->depth++;
12096         if (r->config_file) {
12097                 ndr_print_string(ndr, "config_file", r->config_file);
12098         }
12099         ndr->depth--;
12100         ndr_print_ptr(ndr, "help_file", r->help_file);
12101         ndr->depth++;
12102         if (r->help_file) {
12103                 ndr_print_string(ndr, "help_file", r->help_file);
12104         }
12105         ndr->depth--;
12106         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12107         ndr->depth++;
12108         if (r->dependent_files) {
12109                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12110         }
12111         ndr->depth--;
12112         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12113         ndr->depth++;
12114         if (r->monitor_name) {
12115                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12116         }
12117         ndr->depth--;
12118         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12119         ndr->depth++;
12120         if (r->default_datatype) {
12121                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12122         }
12123         ndr->depth--;
12124         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12125         ndr->depth++;
12126         if (r->previous_names) {
12127                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12128         }
12129         ndr->depth--;
12130         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12131         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12132         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12133         ndr->depth++;
12134         if (r->manufacturer_name) {
12135                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12136         }
12137         ndr->depth--;
12138         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12139         ndr->depth++;
12140         if (r->manufacturer_url) {
12141                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12142         }
12143         ndr->depth--;
12144         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12145         ndr->depth++;
12146         if (r->hardware_id) {
12147                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12148         }
12149         ndr->depth--;
12150         ndr_print_ptr(ndr, "provider", r->provider);
12151         ndr->depth++;
12152         if (r->provider) {
12153                 ndr_print_string(ndr, "provider", r->provider);
12154         }
12155         ndr->depth--;
12156         ndr->depth--;
12157 }
12158
12159 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12160 {
12161         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12162 }
12163
12164 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12165 {
12166         if (ndr_flags & NDR_SCALARS) {
12167                 NDR_CHECK(ndr_push_align(ndr, 8));
12168                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12169                 {
12170                         uint32_t _flags_save_string = ndr->flags;
12171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12172                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12173                         ndr->flags = _flags_save_string;
12174                 }
12175                 {
12176                         uint32_t _flags_save_string = ndr->flags;
12177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12178                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12179                         ndr->flags = _flags_save_string;
12180                 }
12181                 {
12182                         uint32_t _flags_save_string = ndr->flags;
12183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12184                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12185                         ndr->flags = _flags_save_string;
12186                 }
12187                 {
12188                         uint32_t _flags_save_string = ndr->flags;
12189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12190                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12191                         ndr->flags = _flags_save_string;
12192                 }
12193                 {
12194                         uint32_t _flags_save_string = ndr->flags;
12195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12196                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12197                         ndr->flags = _flags_save_string;
12198                 }
12199                 {
12200                         uint32_t _flags_save_string = ndr->flags;
12201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12202                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12203                         ndr->flags = _flags_save_string;
12204                 }
12205                 {
12206                         uint32_t _flags_save_string = ndr->flags;
12207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12208                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12209                         ndr->flags = _flags_save_string;
12210                 }
12211                 {
12212                         uint32_t _flags_save_string = ndr->flags;
12213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12214                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12215                         ndr->flags = _flags_save_string;
12216                 }
12217                 {
12218                         uint32_t _flags_save_string_array = ndr->flags;
12219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12220                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12221                         ndr->flags = _flags_save_string_array;
12222                 }
12223                 {
12224                         uint32_t _flags_save_string_array = ndr->flags;
12225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12226                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12227                         ndr->flags = _flags_save_string_array;
12228                 }
12229                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12230                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12231                 {
12232                         uint32_t _flags_save_string = ndr->flags;
12233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12235                         ndr->flags = _flags_save_string;
12236                 }
12237                 {
12238                         uint32_t _flags_save_string = ndr->flags;
12239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12241                         ndr->flags = _flags_save_string;
12242                 }
12243                 {
12244                         uint32_t _flags_save_string = ndr->flags;
12245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12246                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12247                         ndr->flags = _flags_save_string;
12248                 }
12249                 {
12250                         uint32_t _flags_save_string = ndr->flags;
12251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12252                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12253                         ndr->flags = _flags_save_string;
12254                 }
12255                 {
12256                         uint32_t _flags_save_string = ndr->flags;
12257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12258                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12259                         ndr->flags = _flags_save_string;
12260                 }
12261                 {
12262                         uint32_t _flags_save_string = ndr->flags;
12263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12264                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12265                         ndr->flags = _flags_save_string;
12266                 }
12267                 {
12268                         uint32_t _flags_save_string_array = ndr->flags;
12269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12270                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12271                         ndr->flags = _flags_save_string_array;
12272                 }
12273                 {
12274                         uint32_t _flags_save_string = ndr->flags;
12275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12276                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12277                         ndr->flags = _flags_save_string;
12278                 }
12279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12280                 {
12281                         uint32_t _flags_save_string_array = ndr->flags;
12282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12283                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12284                         ndr->flags = _flags_save_string_array;
12285                 }
12286                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12287                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12288         }
12289         if (ndr_flags & NDR_BUFFERS) {
12290                 {
12291                         uint32_t _flags_save_string = ndr->flags;
12292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12293                         if (r->driver_name) {
12294                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12295                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12296                         }
12297                         ndr->flags = _flags_save_string;
12298                 }
12299                 {
12300                         uint32_t _flags_save_string = ndr->flags;
12301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12302                         if (r->architecture) {
12303                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12304                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12305                         }
12306                         ndr->flags = _flags_save_string;
12307                 }
12308                 {
12309                         uint32_t _flags_save_string = ndr->flags;
12310                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12311                         if (r->driver_path) {
12312                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12313                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12314                         }
12315                         ndr->flags = _flags_save_string;
12316                 }
12317                 {
12318                         uint32_t _flags_save_string = ndr->flags;
12319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12320                         if (r->data_file) {
12321                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12322                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12323                         }
12324                         ndr->flags = _flags_save_string;
12325                 }
12326                 {
12327                         uint32_t _flags_save_string = ndr->flags;
12328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12329                         if (r->config_file) {
12330                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12331                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12332                         }
12333                         ndr->flags = _flags_save_string;
12334                 }
12335                 {
12336                         uint32_t _flags_save_string = ndr->flags;
12337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12338                         if (r->help_file) {
12339                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12340                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12341                         }
12342                         ndr->flags = _flags_save_string;
12343                 }
12344                 {
12345                         uint32_t _flags_save_string = ndr->flags;
12346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12347                         if (r->monitor_name) {
12348                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12349                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12350                         }
12351                         ndr->flags = _flags_save_string;
12352                 }
12353                 {
12354                         uint32_t _flags_save_string = ndr->flags;
12355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12356                         if (r->default_datatype) {
12357                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12358                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12359                         }
12360                         ndr->flags = _flags_save_string;
12361                 }
12362                 {
12363                         uint32_t _flags_save_string_array = ndr->flags;
12364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12365                         if (r->dependent_files) {
12366                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12367                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12368                         }
12369                         ndr->flags = _flags_save_string_array;
12370                 }
12371                 {
12372                         uint32_t _flags_save_string_array = ndr->flags;
12373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12374                         if (r->previous_names) {
12375                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12376                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12377                         }
12378                         ndr->flags = _flags_save_string_array;
12379                 }
12380                 {
12381                         uint32_t _flags_save_string = ndr->flags;
12382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12383                         if (r->manufacturer_name) {
12384                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12385                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12386                         }
12387                         ndr->flags = _flags_save_string;
12388                 }
12389                 {
12390                         uint32_t _flags_save_string = ndr->flags;
12391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12392                         if (r->manufacturer_url) {
12393                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12394                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12395                         }
12396                         ndr->flags = _flags_save_string;
12397                 }
12398                 {
12399                         uint32_t _flags_save_string = ndr->flags;
12400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12401                         if (r->hardware_id) {
12402                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12403                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12404                         }
12405                         ndr->flags = _flags_save_string;
12406                 }
12407                 {
12408                         uint32_t _flags_save_string = ndr->flags;
12409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12410                         if (r->provider) {
12411                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12412                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12413                         }
12414                         ndr->flags = _flags_save_string;
12415                 }
12416                 {
12417                         uint32_t _flags_save_string = ndr->flags;
12418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12419                         if (r->print_processor) {
12420                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12421                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12422                         }
12423                         ndr->flags = _flags_save_string;
12424                 }
12425                 {
12426                         uint32_t _flags_save_string = ndr->flags;
12427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12428                         if (r->vendor_setup) {
12429                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12430                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12431                         }
12432                         ndr->flags = _flags_save_string;
12433                 }
12434                 {
12435                         uint32_t _flags_save_string_array = ndr->flags;
12436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12437                         if (r->color_profiles) {
12438                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12439                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12440                         }
12441                         ndr->flags = _flags_save_string_array;
12442                 }
12443                 {
12444                         uint32_t _flags_save_string = ndr->flags;
12445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12446                         if (r->inf_path) {
12447                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12448                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12449                         }
12450                         ndr->flags = _flags_save_string;
12451                 }
12452                 {
12453                         uint32_t _flags_save_string_array = ndr->flags;
12454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12455                         if (r->core_driver_dependencies) {
12456                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12457                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12458                         }
12459                         ndr->flags = _flags_save_string_array;
12460                 }
12461         }
12462         return NDR_ERR_SUCCESS;
12463 }
12464
12465 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12466 {
12467         uint32_t _ptr_driver_name;
12468         TALLOC_CTX *_mem_save_driver_name_0;
12469         uint32_t _ptr_architecture;
12470         TALLOC_CTX *_mem_save_architecture_0;
12471         uint32_t _ptr_driver_path;
12472         TALLOC_CTX *_mem_save_driver_path_0;
12473         uint32_t _ptr_data_file;
12474         TALLOC_CTX *_mem_save_data_file_0;
12475         uint32_t _ptr_config_file;
12476         TALLOC_CTX *_mem_save_config_file_0;
12477         uint32_t _ptr_help_file;
12478         TALLOC_CTX *_mem_save_help_file_0;
12479         uint32_t _ptr_monitor_name;
12480         TALLOC_CTX *_mem_save_monitor_name_0;
12481         uint32_t _ptr_default_datatype;
12482         TALLOC_CTX *_mem_save_default_datatype_0;
12483         uint32_t _ptr_dependent_files;
12484         TALLOC_CTX *_mem_save_dependent_files_0;
12485         uint32_t _ptr_previous_names;
12486         TALLOC_CTX *_mem_save_previous_names_0;
12487         uint32_t _ptr_manufacturer_name;
12488         TALLOC_CTX *_mem_save_manufacturer_name_0;
12489         uint32_t _ptr_manufacturer_url;
12490         TALLOC_CTX *_mem_save_manufacturer_url_0;
12491         uint32_t _ptr_hardware_id;
12492         TALLOC_CTX *_mem_save_hardware_id_0;
12493         uint32_t _ptr_provider;
12494         TALLOC_CTX *_mem_save_provider_0;
12495         uint32_t _ptr_print_processor;
12496         TALLOC_CTX *_mem_save_print_processor_0;
12497         uint32_t _ptr_vendor_setup;
12498         TALLOC_CTX *_mem_save_vendor_setup_0;
12499         uint32_t _ptr_color_profiles;
12500         TALLOC_CTX *_mem_save_color_profiles_0;
12501         uint32_t _ptr_inf_path;
12502         TALLOC_CTX *_mem_save_inf_path_0;
12503         uint32_t _ptr_core_driver_dependencies;
12504         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12505         if (ndr_flags & NDR_SCALARS) {
12506                 NDR_CHECK(ndr_pull_align(ndr, 8));
12507                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12508                 {
12509                         uint32_t _flags_save_string = ndr->flags;
12510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12511                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12512                         if (_ptr_driver_name) {
12513                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12514                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12515                         } else {
12516                                 r->driver_name = NULL;
12517                         }
12518                         ndr->flags = _flags_save_string;
12519                 }
12520                 {
12521                         uint32_t _flags_save_string = ndr->flags;
12522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12523                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12524                         if (_ptr_architecture) {
12525                                 NDR_PULL_ALLOC(ndr, r->architecture);
12526                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12527                         } else {
12528                                 r->architecture = NULL;
12529                         }
12530                         ndr->flags = _flags_save_string;
12531                 }
12532                 {
12533                         uint32_t _flags_save_string = ndr->flags;
12534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12535                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12536                         if (_ptr_driver_path) {
12537                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12538                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12539                         } else {
12540                                 r->driver_path = NULL;
12541                         }
12542                         ndr->flags = _flags_save_string;
12543                 }
12544                 {
12545                         uint32_t _flags_save_string = ndr->flags;
12546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12547                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12548                         if (_ptr_data_file) {
12549                                 NDR_PULL_ALLOC(ndr, r->data_file);
12550                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12551                         } else {
12552                                 r->data_file = NULL;
12553                         }
12554                         ndr->flags = _flags_save_string;
12555                 }
12556                 {
12557                         uint32_t _flags_save_string = ndr->flags;
12558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12560                         if (_ptr_config_file) {
12561                                 NDR_PULL_ALLOC(ndr, r->config_file);
12562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12563                         } else {
12564                                 r->config_file = NULL;
12565                         }
12566                         ndr->flags = _flags_save_string;
12567                 }
12568                 {
12569                         uint32_t _flags_save_string = ndr->flags;
12570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12571                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12572                         if (_ptr_help_file) {
12573                                 NDR_PULL_ALLOC(ndr, r->help_file);
12574                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12575                         } else {
12576                                 r->help_file = NULL;
12577                         }
12578                         ndr->flags = _flags_save_string;
12579                 }
12580                 {
12581                         uint32_t _flags_save_string = ndr->flags;
12582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12583                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12584                         if (_ptr_monitor_name) {
12585                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12586                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12587                         } else {
12588                                 r->monitor_name = NULL;
12589                         }
12590                         ndr->flags = _flags_save_string;
12591                 }
12592                 {
12593                         uint32_t _flags_save_string = ndr->flags;
12594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12595                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12596                         if (_ptr_default_datatype) {
12597                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12598                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12599                         } else {
12600                                 r->default_datatype = NULL;
12601                         }
12602                         ndr->flags = _flags_save_string;
12603                 }
12604                 {
12605                         uint32_t _flags_save_string_array = ndr->flags;
12606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12607                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12608                         if (_ptr_dependent_files) {
12609                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12610                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12611                         } else {
12612                                 r->dependent_files = NULL;
12613                         }
12614                         ndr->flags = _flags_save_string_array;
12615                 }
12616                 {
12617                         uint32_t _flags_save_string_array = ndr->flags;
12618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12619                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12620                         if (_ptr_previous_names) {
12621                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12622                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12623                         } else {
12624                                 r->previous_names = NULL;
12625                         }
12626                         ndr->flags = _flags_save_string_array;
12627                 }
12628                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12629                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12630                 {
12631                         uint32_t _flags_save_string = ndr->flags;
12632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12633                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12634                         if (_ptr_manufacturer_name) {
12635                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12636                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12637                         } else {
12638                                 r->manufacturer_name = NULL;
12639                         }
12640                         ndr->flags = _flags_save_string;
12641                 }
12642                 {
12643                         uint32_t _flags_save_string = ndr->flags;
12644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12645                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12646                         if (_ptr_manufacturer_url) {
12647                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12648                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12649                         } else {
12650                                 r->manufacturer_url = NULL;
12651                         }
12652                         ndr->flags = _flags_save_string;
12653                 }
12654                 {
12655                         uint32_t _flags_save_string = ndr->flags;
12656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12657                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12658                         if (_ptr_hardware_id) {
12659                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12660                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12661                         } else {
12662                                 r->hardware_id = NULL;
12663                         }
12664                         ndr->flags = _flags_save_string;
12665                 }
12666                 {
12667                         uint32_t _flags_save_string = ndr->flags;
12668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12669                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12670                         if (_ptr_provider) {
12671                                 NDR_PULL_ALLOC(ndr, r->provider);
12672                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12673                         } else {
12674                                 r->provider = NULL;
12675                         }
12676                         ndr->flags = _flags_save_string;
12677                 }
12678                 {
12679                         uint32_t _flags_save_string = ndr->flags;
12680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12681                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12682                         if (_ptr_print_processor) {
12683                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12684                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12685                         } else {
12686                                 r->print_processor = NULL;
12687                         }
12688                         ndr->flags = _flags_save_string;
12689                 }
12690                 {
12691                         uint32_t _flags_save_string = ndr->flags;
12692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12694                         if (_ptr_vendor_setup) {
12695                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12697                         } else {
12698                                 r->vendor_setup = NULL;
12699                         }
12700                         ndr->flags = _flags_save_string;
12701                 }
12702                 {
12703                         uint32_t _flags_save_string_array = ndr->flags;
12704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12706                         if (_ptr_color_profiles) {
12707                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12709                         } else {
12710                                 r->color_profiles = NULL;
12711                         }
12712                         ndr->flags = _flags_save_string_array;
12713                 }
12714                 {
12715                         uint32_t _flags_save_string = ndr->flags;
12716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12718                         if (_ptr_inf_path) {
12719                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12721                         } else {
12722                                 r->inf_path = NULL;
12723                         }
12724                         ndr->flags = _flags_save_string;
12725                 }
12726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12727                 {
12728                         uint32_t _flags_save_string_array = ndr->flags;
12729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12730                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12731                         if (_ptr_core_driver_dependencies) {
12732                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12733                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12734                         } else {
12735                                 r->core_driver_dependencies = NULL;
12736                         }
12737                         ndr->flags = _flags_save_string_array;
12738                 }
12739                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12740                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12741         }
12742         if (ndr_flags & NDR_BUFFERS) {
12743                 {
12744                         uint32_t _flags_save_string = ndr->flags;
12745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12746                         if (r->driver_name) {
12747                                 uint32_t _relative_save_offset;
12748                                 _relative_save_offset = ndr->offset;
12749                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12750                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12751                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12752                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12753                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12754                                 ndr->offset = _relative_save_offset;
12755                         }
12756                         ndr->flags = _flags_save_string;
12757                 }
12758                 {
12759                         uint32_t _flags_save_string = ndr->flags;
12760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12761                         if (r->architecture) {
12762                                 uint32_t _relative_save_offset;
12763                                 _relative_save_offset = ndr->offset;
12764                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12765                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12766                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12767                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12768                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12769                                 ndr->offset = _relative_save_offset;
12770                         }
12771                         ndr->flags = _flags_save_string;
12772                 }
12773                 {
12774                         uint32_t _flags_save_string = ndr->flags;
12775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12776                         if (r->driver_path) {
12777                                 uint32_t _relative_save_offset;
12778                                 _relative_save_offset = ndr->offset;
12779                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12780                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12781                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12782                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12783                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12784                                 ndr->offset = _relative_save_offset;
12785                         }
12786                         ndr->flags = _flags_save_string;
12787                 }
12788                 {
12789                         uint32_t _flags_save_string = ndr->flags;
12790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12791                         if (r->data_file) {
12792                                 uint32_t _relative_save_offset;
12793                                 _relative_save_offset = ndr->offset;
12794                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12795                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12796                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12797                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12798                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12799                                 ndr->offset = _relative_save_offset;
12800                         }
12801                         ndr->flags = _flags_save_string;
12802                 }
12803                 {
12804                         uint32_t _flags_save_string = ndr->flags;
12805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12806                         if (r->config_file) {
12807                                 uint32_t _relative_save_offset;
12808                                 _relative_save_offset = ndr->offset;
12809                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12810                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12811                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12812                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12813                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12814                                 ndr->offset = _relative_save_offset;
12815                         }
12816                         ndr->flags = _flags_save_string;
12817                 }
12818                 {
12819                         uint32_t _flags_save_string = ndr->flags;
12820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12821                         if (r->help_file) {
12822                                 uint32_t _relative_save_offset;
12823                                 _relative_save_offset = ndr->offset;
12824                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12825                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12826                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12827                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12828                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12829                                 ndr->offset = _relative_save_offset;
12830                         }
12831                         ndr->flags = _flags_save_string;
12832                 }
12833                 {
12834                         uint32_t _flags_save_string = ndr->flags;
12835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12836                         if (r->monitor_name) {
12837                                 uint32_t _relative_save_offset;
12838                                 _relative_save_offset = ndr->offset;
12839                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12840                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12841                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12842                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12843                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12844                                 ndr->offset = _relative_save_offset;
12845                         }
12846                         ndr->flags = _flags_save_string;
12847                 }
12848                 {
12849                         uint32_t _flags_save_string = ndr->flags;
12850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12851                         if (r->default_datatype) {
12852                                 uint32_t _relative_save_offset;
12853                                 _relative_save_offset = ndr->offset;
12854                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12855                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12856                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12857                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12858                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12859                                 ndr->offset = _relative_save_offset;
12860                         }
12861                         ndr->flags = _flags_save_string;
12862                 }
12863                 {
12864                         uint32_t _flags_save_string_array = ndr->flags;
12865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12866                         if (r->dependent_files) {
12867                                 uint32_t _relative_save_offset;
12868                                 _relative_save_offset = ndr->offset;
12869                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12870                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12871                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12872                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12873                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12874                                 ndr->offset = _relative_save_offset;
12875                         }
12876                         ndr->flags = _flags_save_string_array;
12877                 }
12878                 {
12879                         uint32_t _flags_save_string_array = ndr->flags;
12880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12881                         if (r->previous_names) {
12882                                 uint32_t _relative_save_offset;
12883                                 _relative_save_offset = ndr->offset;
12884                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12885                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12886                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12887                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12888                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12889                                 ndr->offset = _relative_save_offset;
12890                         }
12891                         ndr->flags = _flags_save_string_array;
12892                 }
12893                 {
12894                         uint32_t _flags_save_string = ndr->flags;
12895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12896                         if (r->manufacturer_name) {
12897                                 uint32_t _relative_save_offset;
12898                                 _relative_save_offset = ndr->offset;
12899                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12900                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12901                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12902                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12903                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12904                                 ndr->offset = _relative_save_offset;
12905                         }
12906                         ndr->flags = _flags_save_string;
12907                 }
12908                 {
12909                         uint32_t _flags_save_string = ndr->flags;
12910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12911                         if (r->manufacturer_url) {
12912                                 uint32_t _relative_save_offset;
12913                                 _relative_save_offset = ndr->offset;
12914                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12915                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12916                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12917                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12918                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12919                                 ndr->offset = _relative_save_offset;
12920                         }
12921                         ndr->flags = _flags_save_string;
12922                 }
12923                 {
12924                         uint32_t _flags_save_string = ndr->flags;
12925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12926                         if (r->hardware_id) {
12927                                 uint32_t _relative_save_offset;
12928                                 _relative_save_offset = ndr->offset;
12929                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12930                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12931                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12932                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12933                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12934                                 ndr->offset = _relative_save_offset;
12935                         }
12936                         ndr->flags = _flags_save_string;
12937                 }
12938                 {
12939                         uint32_t _flags_save_string = ndr->flags;
12940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12941                         if (r->provider) {
12942                                 uint32_t _relative_save_offset;
12943                                 _relative_save_offset = ndr->offset;
12944                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12945                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12946                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12947                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12948                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12949                                 ndr->offset = _relative_save_offset;
12950                         }
12951                         ndr->flags = _flags_save_string;
12952                 }
12953                 {
12954                         uint32_t _flags_save_string = ndr->flags;
12955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12956                         if (r->print_processor) {
12957                                 uint32_t _relative_save_offset;
12958                                 _relative_save_offset = ndr->offset;
12959                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
12960                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
12961                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
12962                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
12963                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
12964                                 ndr->offset = _relative_save_offset;
12965                         }
12966                         ndr->flags = _flags_save_string;
12967                 }
12968                 {
12969                         uint32_t _flags_save_string = ndr->flags;
12970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12971                         if (r->vendor_setup) {
12972                                 uint32_t _relative_save_offset;
12973                                 _relative_save_offset = ndr->offset;
12974                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
12975                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
12976                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
12977                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
12978                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
12979                                 ndr->offset = _relative_save_offset;
12980                         }
12981                         ndr->flags = _flags_save_string;
12982                 }
12983                 {
12984                         uint32_t _flags_save_string_array = ndr->flags;
12985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12986                         if (r->color_profiles) {
12987                                 uint32_t _relative_save_offset;
12988                                 _relative_save_offset = ndr->offset;
12989                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
12990                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
12991                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
12992                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
12993                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
12994                                 ndr->offset = _relative_save_offset;
12995                         }
12996                         ndr->flags = _flags_save_string_array;
12997                 }
12998                 {
12999                         uint32_t _flags_save_string = ndr->flags;
13000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13001                         if (r->inf_path) {
13002                                 uint32_t _relative_save_offset;
13003                                 _relative_save_offset = ndr->offset;
13004                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13005                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13006                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13007                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13008                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13009                                 ndr->offset = _relative_save_offset;
13010                         }
13011                         ndr->flags = _flags_save_string;
13012                 }
13013                 {
13014                         uint32_t _flags_save_string_array = ndr->flags;
13015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13016                         if (r->core_driver_dependencies) {
13017                                 uint32_t _relative_save_offset;
13018                                 _relative_save_offset = ndr->offset;
13019                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13020                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13021                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13022                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13023                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13024                                 ndr->offset = _relative_save_offset;
13025                         }
13026                         ndr->flags = _flags_save_string_array;
13027                 }
13028         }
13029         return NDR_ERR_SUCCESS;
13030 }
13031
13032 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13033 {
13034         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13035         ndr->depth++;
13036         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13037         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13038         ndr->depth++;
13039         if (r->driver_name) {
13040                 ndr_print_string(ndr, "driver_name", r->driver_name);
13041         }
13042         ndr->depth--;
13043         ndr_print_ptr(ndr, "architecture", r->architecture);
13044         ndr->depth++;
13045         if (r->architecture) {
13046                 ndr_print_string(ndr, "architecture", r->architecture);
13047         }
13048         ndr->depth--;
13049         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13050         ndr->depth++;
13051         if (r->driver_path) {
13052                 ndr_print_string(ndr, "driver_path", r->driver_path);
13053         }
13054         ndr->depth--;
13055         ndr_print_ptr(ndr, "data_file", r->data_file);
13056         ndr->depth++;
13057         if (r->data_file) {
13058                 ndr_print_string(ndr, "data_file", r->data_file);
13059         }
13060         ndr->depth--;
13061         ndr_print_ptr(ndr, "config_file", r->config_file);
13062         ndr->depth++;
13063         if (r->config_file) {
13064                 ndr_print_string(ndr, "config_file", r->config_file);
13065         }
13066         ndr->depth--;
13067         ndr_print_ptr(ndr, "help_file", r->help_file);
13068         ndr->depth++;
13069         if (r->help_file) {
13070                 ndr_print_string(ndr, "help_file", r->help_file);
13071         }
13072         ndr->depth--;
13073         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13074         ndr->depth++;
13075         if (r->monitor_name) {
13076                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13077         }
13078         ndr->depth--;
13079         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13080         ndr->depth++;
13081         if (r->default_datatype) {
13082                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13083         }
13084         ndr->depth--;
13085         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13086         ndr->depth++;
13087         if (r->dependent_files) {
13088                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13089         }
13090         ndr->depth--;
13091         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13092         ndr->depth++;
13093         if (r->previous_names) {
13094                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13095         }
13096         ndr->depth--;
13097         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13098         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13099         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13100         ndr->depth++;
13101         if (r->manufacturer_name) {
13102                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13103         }
13104         ndr->depth--;
13105         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13106         ndr->depth++;
13107         if (r->manufacturer_url) {
13108                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13109         }
13110         ndr->depth--;
13111         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13112         ndr->depth++;
13113         if (r->hardware_id) {
13114                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13115         }
13116         ndr->depth--;
13117         ndr_print_ptr(ndr, "provider", r->provider);
13118         ndr->depth++;
13119         if (r->provider) {
13120                 ndr_print_string(ndr, "provider", r->provider);
13121         }
13122         ndr->depth--;
13123         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13124         ndr->depth++;
13125         if (r->print_processor) {
13126                 ndr_print_string(ndr, "print_processor", r->print_processor);
13127         }
13128         ndr->depth--;
13129         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13130         ndr->depth++;
13131         if (r->vendor_setup) {
13132                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13133         }
13134         ndr->depth--;
13135         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13136         ndr->depth++;
13137         if (r->color_profiles) {
13138                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13139         }
13140         ndr->depth--;
13141         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13142         ndr->depth++;
13143         if (r->inf_path) {
13144                 ndr_print_string(ndr, "inf_path", r->inf_path);
13145         }
13146         ndr->depth--;
13147         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13148         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13149         ndr->depth++;
13150         if (r->core_driver_dependencies) {
13151                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13152         }
13153         ndr->depth--;
13154         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13155         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13156         ndr->depth--;
13157 }
13158
13159 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13160 {
13161         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13162 }
13163
13164 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13165 {
13166         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13167         return NDR_ERR_SUCCESS;
13168 }
13169
13170 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13171 {
13172         uint32_t v;
13173         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13174         *r = v;
13175         return NDR_ERR_SUCCESS;
13176 }
13177
13178 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13179 {
13180         const char *val = NULL;
13181
13182         switch (r) {
13183                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13184                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13185                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13186                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13187                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13188         }
13189         ndr_print_enum(ndr, name, "ENUM", val, r);
13190 }
13191
13192 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13193 {
13194         if (ndr_flags & NDR_SCALARS) {
13195                 NDR_CHECK(ndr_push_align(ndr, 4));
13196                 {
13197                         uint32_t _flags_save_string = ndr->flags;
13198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13199                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13200                         ndr->flags = _flags_save_string;
13201                 }
13202                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13204         }
13205         if (ndr_flags & NDR_BUFFERS) {
13206                 {
13207                         uint32_t _flags_save_string = ndr->flags;
13208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13209                         if (r->file_name) {
13210                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13211                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13212                         }
13213                         ndr->flags = _flags_save_string;
13214                 }
13215         }
13216         return NDR_ERR_SUCCESS;
13217 }
13218
13219 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13220 {
13221         uint32_t _ptr_file_name;
13222         TALLOC_CTX *_mem_save_file_name_0;
13223         if (ndr_flags & NDR_SCALARS) {
13224                 NDR_CHECK(ndr_pull_align(ndr, 4));
13225                 {
13226                         uint32_t _flags_save_string = ndr->flags;
13227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13229                         if (_ptr_file_name) {
13230                                 NDR_PULL_ALLOC(ndr, r->file_name);
13231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13232                         } else {
13233                                 r->file_name = NULL;
13234                         }
13235                         ndr->flags = _flags_save_string;
13236                 }
13237                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13239         }
13240         if (ndr_flags & NDR_BUFFERS) {
13241                 {
13242                         uint32_t _flags_save_string = ndr->flags;
13243                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13244                         if (r->file_name) {
13245                                 uint32_t _relative_save_offset;
13246                                 _relative_save_offset = ndr->offset;
13247                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13248                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13249                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13250                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13251                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13252                                 ndr->offset = _relative_save_offset;
13253                         }
13254                         ndr->flags = _flags_save_string;
13255                 }
13256         }
13257         return NDR_ERR_SUCCESS;
13258 }
13259
13260 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13261 {
13262         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13263         ndr->depth++;
13264         ndr_print_ptr(ndr, "file_name", r->file_name);
13265         ndr->depth++;
13266         if (r->file_name) {
13267                 ndr_print_string(ndr, "file_name", r->file_name);
13268         }
13269         ndr->depth--;
13270         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13271         ndr_print_uint32(ndr, "file_version", r->file_version);
13272         ndr->depth--;
13273 }
13274
13275 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13276 {
13277         uint32_t cntr_file_info_1;
13278         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13279         ndr->depth++;
13280         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13281         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13282         ndr->depth++;
13283         if (r->driver_name) {
13284                 ndr_print_string(ndr, "driver_name", r->driver_name);
13285         }
13286         ndr->depth--;
13287         ndr_print_ptr(ndr, "architecture", r->architecture);
13288         ndr->depth++;
13289         if (r->architecture) {
13290                 ndr_print_string(ndr, "architecture", r->architecture);
13291         }
13292         ndr->depth--;
13293         ndr_print_ptr(ndr, "file_info", r->file_info);
13294         ndr->depth++;
13295         if (r->file_info) {
13296                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13297                 ndr->depth++;
13298                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13299                         char *idx_1=NULL;
13300                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13301                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13302                                 free(idx_1);
13303                         }
13304                 }
13305                 ndr->depth--;
13306         }
13307         ndr->depth--;
13308         ndr_print_uint32(ndr, "file_count", r->file_count);
13309         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13310         ndr->depth++;
13311         if (r->monitor_name) {
13312                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13313         }
13314         ndr->depth--;
13315         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13316         ndr->depth++;
13317         if (r->default_datatype) {
13318                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13319         }
13320         ndr->depth--;
13321         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13322         ndr->depth++;
13323         if (r->previous_names) {
13324                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13325         }
13326         ndr->depth--;
13327         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13328         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13329         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13330         ndr->depth++;
13331         if (r->manufacturer_name) {
13332                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13333         }
13334         ndr->depth--;
13335         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13336         ndr->depth++;
13337         if (r->manufacturer_url) {
13338                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13339         }
13340         ndr->depth--;
13341         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13342         ndr->depth++;
13343         if (r->hardware_id) {
13344                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13345         }
13346         ndr->depth--;
13347         ndr_print_ptr(ndr, "provider", r->provider);
13348         ndr->depth++;
13349         if (r->provider) {
13350                 ndr_print_string(ndr, "provider", r->provider);
13351         }
13352         ndr->depth--;
13353         ndr->depth--;
13354 }
13355
13356 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13357 {
13358         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13359 }
13360
13361 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13362 {
13363         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13364         if (ndr_flags & NDR_SCALARS) {
13365                 int level = ndr_push_get_switch_value(ndr, r);
13366                 switch (level) {
13367                         case 1: {
13368                                 NDR_CHECK(ndr_push_align(ndr, 4));
13369                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13370                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13371                         break; }
13372
13373                         case 2: {
13374                                 NDR_CHECK(ndr_push_align(ndr, 4));
13375                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13376                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13377                         break; }
13378
13379                         case 3: {
13380                                 NDR_CHECK(ndr_push_align(ndr, 4));
13381                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13382                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13383                         break; }
13384
13385                         case 4: {
13386                                 NDR_CHECK(ndr_push_align(ndr, 4));
13387                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13388                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13389                         break; }
13390
13391                         case 5: {
13392                                 NDR_CHECK(ndr_push_align(ndr, 4));
13393                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13394                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13395                         break; }
13396
13397                         case 6: {
13398                                 NDR_CHECK(ndr_push_align(ndr, 8));
13399                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13400                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13401                         break; }
13402
13403                         case 8: {
13404                                 NDR_CHECK(ndr_push_align(ndr, 8));
13405                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13406                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13407                         break; }
13408
13409                         case 101: {
13410                                 NDR_CHECK(ndr_push_align(ndr, 8));
13411                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13412                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13413                         break; }
13414
13415                         default: {
13416                         break; }
13417
13418                 }
13419         }
13420         if (ndr_flags & NDR_BUFFERS) {
13421                 int level = ndr_push_get_switch_value(ndr, r);
13422                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13423                 switch (level) {
13424                         case 1:
13425                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13426                         break;
13427
13428                         case 2:
13429                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13430                         break;
13431
13432                         case 3:
13433                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13434                         break;
13435
13436                         case 4:
13437                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13438                         break;
13439
13440                         case 5:
13441                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13442                         break;
13443
13444                         case 6:
13445                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13446                         break;
13447
13448                         case 8:
13449                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13450                         break;
13451
13452                         case 101:
13453                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13454                         break;
13455
13456                         default:
13457                         break;
13458
13459                 }
13460         }
13461         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13462         return NDR_ERR_SUCCESS;
13463 }
13464
13465 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13466 {
13467         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13468         int level;
13469         level = ndr_pull_get_switch_value(ndr, r);
13470         if (ndr_flags & NDR_SCALARS) {
13471                 switch (level) {
13472                         case 1: {
13473                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13474                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13475                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13476                         break; }
13477
13478                         case 2: {
13479                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13480                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13481                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13482                         break; }
13483
13484                         case 3: {
13485                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13486                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13487                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13488                         break; }
13489
13490                         case 4: {
13491                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13492                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13493                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13494                         break; }
13495
13496                         case 5: {
13497                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13498                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13499                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13500                         break; }
13501
13502                         case 6: {
13503                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13504                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13505                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13506                         break; }
13507
13508                         case 8: {
13509                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13510                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13511                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13512                         break; }
13513
13514                         case 101: {
13515                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13516                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13517                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13518                         break; }
13519
13520                         default: {
13521                         break; }
13522
13523                 }
13524         }
13525         if (ndr_flags & NDR_BUFFERS) {
13526                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13527                 switch (level) {
13528                         case 1:
13529                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13530                         break;
13531
13532                         case 2:
13533                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13534                         break;
13535
13536                         case 3:
13537                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13538                         break;
13539
13540                         case 4:
13541                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13542                         break;
13543
13544                         case 5:
13545                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13546                         break;
13547
13548                         case 6:
13549                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13550                         break;
13551
13552                         case 8:
13553                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13554                         break;
13555
13556                         case 101:
13557                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13558                         break;
13559
13560                         default:
13561                         break;
13562
13563                 }
13564         }
13565         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13566         return NDR_ERR_SUCCESS;
13567 }
13568
13569 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13570 {
13571         int level;
13572         level = ndr_print_get_switch_value(ndr, r);
13573         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13574         switch (level) {
13575                 case 1:
13576                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13577                 break;
13578
13579                 case 2:
13580                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13581                 break;
13582
13583                 case 3:
13584                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13585                 break;
13586
13587                 case 4:
13588                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13589                 break;
13590
13591                 case 5:
13592                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13593                 break;
13594
13595                 case 6:
13596                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13597                 break;
13598
13599                 case 8:
13600                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13601                 break;
13602
13603                 case 101:
13604                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13605                 break;
13606
13607                 default:
13608                 break;
13609
13610         }
13611 }
13612
13613 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13614 {
13615         if (ndr_flags & NDR_SCALARS) {
13616                 NDR_CHECK(ndr_push_align(ndr, 4));
13617                 {
13618                         uint32_t _flags_save_string = ndr->flags;
13619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13620                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13621                         ndr->flags = _flags_save_string;
13622                 }
13623         }
13624         if (ndr_flags & NDR_BUFFERS) {
13625         }
13626         return NDR_ERR_SUCCESS;
13627 }
13628
13629 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13630 {
13631         if (ndr_flags & NDR_SCALARS) {
13632                 NDR_CHECK(ndr_pull_align(ndr, 4));
13633                 {
13634                         uint32_t _flags_save_string = ndr->flags;
13635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13636                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13637                         ndr->flags = _flags_save_string;
13638                 }
13639         }
13640         if (ndr_flags & NDR_BUFFERS) {
13641         }
13642         return NDR_ERR_SUCCESS;
13643 }
13644
13645 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13646 {
13647         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13648         ndr->depth++;
13649         ndr_print_string(ndr, "directory_name", r->directory_name);
13650         ndr->depth--;
13651 }
13652
13653 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13654 {
13655         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13656 }
13657
13658 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13659 {
13660         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13661         if (ndr_flags & NDR_SCALARS) {
13662                 int level = ndr_push_get_switch_value(ndr, r);
13663                 switch (level) {
13664                         case 1: {
13665                                 NDR_CHECK(ndr_push_align(ndr, 4));
13666                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13667                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13668                         break; }
13669
13670                         default: {
13671                                 NDR_CHECK(ndr_push_align(ndr, 4));
13672                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13673                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13674                         break; }
13675
13676                 }
13677         }
13678         if (ndr_flags & NDR_BUFFERS) {
13679                 int level = ndr_push_get_switch_value(ndr, r);
13680                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13681                 switch (level) {
13682                         case 1:
13683                         break;
13684
13685                         default:
13686                         break;
13687
13688                 }
13689         }
13690         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13691         return NDR_ERR_SUCCESS;
13692 }
13693
13694 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13695 {
13696         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13697         int level;
13698         level = ndr_pull_get_switch_value(ndr, r);
13699         if (ndr_flags & NDR_SCALARS) {
13700                 switch (level) {
13701                         case 1: {
13702                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13703                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13704                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13705                         break; }
13706
13707                         default: {
13708                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13709                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13710                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13711                         break; }
13712
13713                 }
13714         }
13715         if (ndr_flags & NDR_BUFFERS) {
13716                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13717                 switch (level) {
13718                         case 1:
13719                         break;
13720
13721                         default:
13722                         break;
13723
13724                 }
13725         }
13726         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13727         return NDR_ERR_SUCCESS;
13728 }
13729
13730 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13731 {
13732         int level;
13733         level = ndr_print_get_switch_value(ndr, r);
13734         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13735         switch (level) {
13736                 case 1:
13737                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13738                 break;
13739
13740                 default:
13741                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13742                 break;
13743
13744         }
13745 }
13746
13747 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13748 {
13749         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13750 }
13751
13752 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13753 {
13754         if (ndr_flags & NDR_SCALARS) {
13755                 NDR_CHECK(ndr_push_align(ndr, 4));
13756                 {
13757                         uint32_t _flags_save_string = ndr->flags;
13758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13759                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13760                         ndr->flags = _flags_save_string;
13761                 }
13762         }
13763         if (ndr_flags & NDR_BUFFERS) {
13764                 {
13765                         uint32_t _flags_save_string = ndr->flags;
13766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13767                         if (r->print_processor_name) {
13768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13770                         }
13771                         ndr->flags = _flags_save_string;
13772                 }
13773         }
13774         return NDR_ERR_SUCCESS;
13775 }
13776
13777 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13778 {
13779         uint32_t _ptr_print_processor_name;
13780         TALLOC_CTX *_mem_save_print_processor_name_0;
13781         if (ndr_flags & NDR_SCALARS) {
13782                 NDR_CHECK(ndr_pull_align(ndr, 4));
13783                 {
13784                         uint32_t _flags_save_string = ndr->flags;
13785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13786                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13787                         if (_ptr_print_processor_name) {
13788                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13789                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13790                         } else {
13791                                 r->print_processor_name = NULL;
13792                         }
13793                         ndr->flags = _flags_save_string;
13794                 }
13795         }
13796         if (ndr_flags & NDR_BUFFERS) {
13797                 {
13798                         uint32_t _flags_save_string = ndr->flags;
13799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13800                         if (r->print_processor_name) {
13801                                 uint32_t _relative_save_offset;
13802                                 _relative_save_offset = ndr->offset;
13803                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13804                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13805                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13806                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13807                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13808                                 ndr->offset = _relative_save_offset;
13809                         }
13810                         ndr->flags = _flags_save_string;
13811                 }
13812         }
13813         return NDR_ERR_SUCCESS;
13814 }
13815
13816 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13817 {
13818         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13819         ndr->depth++;
13820         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13821         ndr->depth++;
13822         if (r->print_processor_name) {
13823                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13824         }
13825         ndr->depth--;
13826         ndr->depth--;
13827 }
13828
13829 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13830 {
13831         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13832 }
13833
13834 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13835 {
13836         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13837         if (ndr_flags & NDR_SCALARS) {
13838                 int level = ndr_push_get_switch_value(ndr, r);
13839                 switch (level) {
13840                         case 1: {
13841                                 NDR_CHECK(ndr_push_align(ndr, 4));
13842                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13843                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13844                         break; }
13845
13846                         default: {
13847                         break; }
13848
13849                 }
13850         }
13851         if (ndr_flags & NDR_BUFFERS) {
13852                 int level = ndr_push_get_switch_value(ndr, r);
13853                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13854                 switch (level) {
13855                         case 1:
13856                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13857                         break;
13858
13859                         default:
13860                         break;
13861
13862                 }
13863         }
13864         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13865         return NDR_ERR_SUCCESS;
13866 }
13867
13868 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13869 {
13870         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13871         int level;
13872         level = ndr_pull_get_switch_value(ndr, r);
13873         if (ndr_flags & NDR_SCALARS) {
13874                 switch (level) {
13875                         case 1: {
13876                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13877                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13878                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13879                         break; }
13880
13881                         default: {
13882                         break; }
13883
13884                 }
13885         }
13886         if (ndr_flags & NDR_BUFFERS) {
13887                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13888                 switch (level) {
13889                         case 1:
13890                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13891                         break;
13892
13893                         default:
13894                         break;
13895
13896                 }
13897         }
13898         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13899         return NDR_ERR_SUCCESS;
13900 }
13901
13902 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
13903 {
13904         int level;
13905         level = ndr_print_get_switch_value(ndr, r);
13906         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
13907         switch (level) {
13908                 case 1:
13909                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
13910                 break;
13911
13912                 default:
13913                 break;
13914
13915         }
13916 }
13917
13918 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13919 {
13920         if (ndr_flags & NDR_SCALARS) {
13921                 NDR_CHECK(ndr_push_align(ndr, 4));
13922                 {
13923                         uint32_t _flags_save_string = ndr->flags;
13924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13925                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13926                         ndr->flags = _flags_save_string;
13927                 }
13928         }
13929         if (ndr_flags & NDR_BUFFERS) {
13930         }
13931         return NDR_ERR_SUCCESS;
13932 }
13933
13934 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
13935 {
13936         if (ndr_flags & NDR_SCALARS) {
13937                 NDR_CHECK(ndr_pull_align(ndr, 4));
13938                 {
13939                         uint32_t _flags_save_string = ndr->flags;
13940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13941                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13942                         ndr->flags = _flags_save_string;
13943                 }
13944         }
13945         if (ndr_flags & NDR_BUFFERS) {
13946         }
13947         return NDR_ERR_SUCCESS;
13948 }
13949
13950 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13951 {
13952         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
13953         ndr->depth++;
13954         ndr_print_string(ndr, "directory_name", r->directory_name);
13955         ndr->depth--;
13956 }
13957
13958 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13959 {
13960         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
13961 }
13962
13963 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
13964 {
13965         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13966         if (ndr_flags & NDR_SCALARS) {
13967                 int level = ndr_push_get_switch_value(ndr, r);
13968                 switch (level) {
13969                         case 1: {
13970                                 NDR_CHECK(ndr_push_align(ndr, 4));
13971                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13972                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13973                         break; }
13974
13975                         default: {
13976                                 NDR_CHECK(ndr_push_align(ndr, 4));
13977                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13978                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13979                         break; }
13980
13981                 }
13982         }
13983         if (ndr_flags & NDR_BUFFERS) {
13984                 int level = ndr_push_get_switch_value(ndr, r);
13985                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13986                 switch (level) {
13987                         case 1:
13988                         break;
13989
13990                         default:
13991                         break;
13992
13993                 }
13994         }
13995         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13996         return NDR_ERR_SUCCESS;
13997 }
13998
13999 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14000 {
14001         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14002         int level;
14003         level = ndr_pull_get_switch_value(ndr, r);
14004         if (ndr_flags & NDR_SCALARS) {
14005                 switch (level) {
14006                         case 1: {
14007                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14008                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14009                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14010                         break; }
14011
14012                         default: {
14013                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14014                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14015                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14016                         break; }
14017
14018                 }
14019         }
14020         if (ndr_flags & NDR_BUFFERS) {
14021                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14022                 switch (level) {
14023                         case 1:
14024                         break;
14025
14026                         default:
14027                         break;
14028
14029                 }
14030         }
14031         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14032         return NDR_ERR_SUCCESS;
14033 }
14034
14035 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14036 {
14037         int level;
14038         level = ndr_print_get_switch_value(ndr, r);
14039         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14040         switch (level) {
14041                 case 1:
14042                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14043                 break;
14044
14045                 default:
14046                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14047                 break;
14048
14049         }
14050 }
14051
14052 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14053 {
14054         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14055 }
14056
14057 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14058 {
14059         if (ndr_flags & NDR_SCALARS) {
14060                 NDR_CHECK(ndr_push_align(ndr, 4));
14061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14064         }
14065         if (ndr_flags & NDR_BUFFERS) {
14066                 if (r->document_name) {
14067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14070                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14071                 }
14072                 if (r->output_file) {
14073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14076                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14077                 }
14078                 if (r->datatype) {
14079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14082                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14083                 }
14084         }
14085         return NDR_ERR_SUCCESS;
14086 }
14087
14088 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14089 {
14090         uint32_t _ptr_document_name;
14091         TALLOC_CTX *_mem_save_document_name_0;
14092         uint32_t _ptr_output_file;
14093         TALLOC_CTX *_mem_save_output_file_0;
14094         uint32_t _ptr_datatype;
14095         TALLOC_CTX *_mem_save_datatype_0;
14096         if (ndr_flags & NDR_SCALARS) {
14097                 NDR_CHECK(ndr_pull_align(ndr, 4));
14098                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14099                 if (_ptr_document_name) {
14100                         NDR_PULL_ALLOC(ndr, r->document_name);
14101                 } else {
14102                         r->document_name = NULL;
14103                 }
14104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14105                 if (_ptr_output_file) {
14106                         NDR_PULL_ALLOC(ndr, r->output_file);
14107                 } else {
14108                         r->output_file = NULL;
14109                 }
14110                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14111                 if (_ptr_datatype) {
14112                         NDR_PULL_ALLOC(ndr, r->datatype);
14113                 } else {
14114                         r->datatype = NULL;
14115                 }
14116         }
14117         if (ndr_flags & NDR_BUFFERS) {
14118                 if (r->document_name) {
14119                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14120                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14121                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14122                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14123                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14124                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
14125                         }
14126                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14127                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14128                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14129                 }
14130                 if (r->output_file) {
14131                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14132                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14133                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14134                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14135                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14136                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->output_file), ndr_get_array_length(ndr, &r->output_file));
14137                         }
14138                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14139                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14141                 }
14142                 if (r->datatype) {
14143                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14144                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14145                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14146                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14147                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14148                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
14149                         }
14150                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14151                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14153                 }
14154         }
14155         return NDR_ERR_SUCCESS;
14156 }
14157
14158 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14159 {
14160         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14161         ndr->depth++;
14162         ndr_print_ptr(ndr, "document_name", r->document_name);
14163         ndr->depth++;
14164         if (r->document_name) {
14165                 ndr_print_string(ndr, "document_name", r->document_name);
14166         }
14167         ndr->depth--;
14168         ndr_print_ptr(ndr, "output_file", r->output_file);
14169         ndr->depth++;
14170         if (r->output_file) {
14171                 ndr_print_string(ndr, "output_file", r->output_file);
14172         }
14173         ndr->depth--;
14174         ndr_print_ptr(ndr, "datatype", r->datatype);
14175         ndr->depth++;
14176         if (r->datatype) {
14177                 ndr_print_string(ndr, "datatype", r->datatype);
14178         }
14179         ndr->depth--;
14180         ndr->depth--;
14181 }
14182
14183 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14184 {
14185         if (ndr_flags & NDR_SCALARS) {
14186                 int level = ndr_push_get_switch_value(ndr, r);
14187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14188                 switch (level) {
14189                         case 1: {
14190                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14191                         break; }
14192
14193                         case 2: {
14194                         break; }
14195
14196                         case 3: {
14197                         break; }
14198
14199                         default: {
14200                         break; }
14201
14202                 }
14203         }
14204         if (ndr_flags & NDR_BUFFERS) {
14205                 int level = ndr_push_get_switch_value(ndr, r);
14206                 switch (level) {
14207                         case 1:
14208                                 if (r->info1) {
14209                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14210                                 }
14211                         break;
14212
14213                         case 2:
14214                         break;
14215
14216                         case 3:
14217                         break;
14218
14219                         default:
14220                         break;
14221
14222                 }
14223         }
14224         return NDR_ERR_SUCCESS;
14225 }
14226
14227 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14228 {
14229         int level;
14230         uint32_t _level;
14231         TALLOC_CTX *_mem_save_info1_0;
14232         level = ndr_pull_get_switch_value(ndr, r);
14233         if (ndr_flags & NDR_SCALARS) {
14234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14235                 if (_level != level) {
14236                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14237                 }
14238                 switch (level) {
14239                         case 1: {
14240                                 uint32_t _ptr_info1;
14241                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14242                                 if (_ptr_info1) {
14243                                         NDR_PULL_ALLOC(ndr, r->info1);
14244                                 } else {
14245                                         r->info1 = NULL;
14246                                 }
14247                         break; }
14248
14249                         case 2: {
14250                         break; }
14251
14252                         case 3: {
14253                         break; }
14254
14255                         default: {
14256                         break; }
14257
14258                 }
14259         }
14260         if (ndr_flags & NDR_BUFFERS) {
14261                 switch (level) {
14262                         case 1:
14263                                 if (r->info1) {
14264                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14265                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14266                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14267                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14268                                 }
14269                         break;
14270
14271                         case 2:
14272                         break;
14273
14274                         case 3:
14275                         break;
14276
14277                         default:
14278                         break;
14279
14280                 }
14281         }
14282         return NDR_ERR_SUCCESS;
14283 }
14284
14285 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14286 {
14287         int level;
14288         level = ndr_print_get_switch_value(ndr, r);
14289         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14290         switch (level) {
14291                 case 1:
14292                         ndr_print_ptr(ndr, "info1", r->info1);
14293                         ndr->depth++;
14294                         if (r->info1) {
14295                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14296                         }
14297                         ndr->depth--;
14298                 break;
14299
14300                 case 2:
14301                 break;
14302
14303                 case 3:
14304                 break;
14305
14306                 default:
14307                 break;
14308
14309         }
14310 }
14311
14312 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14313 {
14314         if (ndr_flags & NDR_SCALARS) {
14315                 NDR_CHECK(ndr_push_align(ndr, 4));
14316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14321                 {
14322                         uint32_t _flags_save_string = ndr->flags;
14323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14324                         {
14325                                 struct ndr_push *_ndr_extra_string;
14326                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14327                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14328                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14329                         }
14330                         ndr->flags = _flags_save_string;
14331                 }
14332         }
14333         if (ndr_flags & NDR_BUFFERS) {
14334         }
14335         return NDR_ERR_SUCCESS;
14336 }
14337
14338 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14339 {
14340         if (ndr_flags & NDR_SCALARS) {
14341                 NDR_CHECK(ndr_pull_align(ndr, 4));
14342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14347                 {
14348                         uint32_t _flags_save_string = ndr->flags;
14349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14350                         {
14351                                 struct ndr_pull *_ndr_extra_string;
14352                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14353                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14354                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14355                         }
14356                         ndr->flags = _flags_save_string;
14357                 }
14358         }
14359         if (ndr_flags & NDR_BUFFERS) {
14360         }
14361         return NDR_ERR_SUCCESS;
14362 }
14363
14364 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14365 {
14366         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14367         ndr->depth++;
14368         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
14369         ndr_print_uint32(ndr, "major", r->major);
14370         ndr_print_uint32(ndr, "minor", r->minor);
14371         ndr_print_uint32(ndr, "build", r->build);
14372         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14373         ndr_print_string(ndr, "extra_string", r->extra_string);
14374         ndr->depth--;
14375 }
14376
14377 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14378 {
14379         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14380 }
14381
14382 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14383 {
14384         if (ndr_flags & NDR_SCALARS) {
14385                 NDR_CHECK(ndr_push_align(ndr, 4));
14386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14391                 {
14392                         uint32_t _flags_save_string = ndr->flags;
14393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14394                         {
14395                                 struct ndr_push *_ndr_extra_string;
14396                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14397                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14398                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14399                         }
14400                         ndr->flags = _flags_save_string;
14401                 }
14402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14404         }
14405         if (ndr_flags & NDR_BUFFERS) {
14406         }
14407         return NDR_ERR_SUCCESS;
14408 }
14409
14410 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14411 {
14412         if (ndr_flags & NDR_SCALARS) {
14413                 NDR_CHECK(ndr_pull_align(ndr, 4));
14414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14419                 {
14420                         uint32_t _flags_save_string = ndr->flags;
14421                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14422                         {
14423                                 struct ndr_pull *_ndr_extra_string;
14424                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14425                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14426                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14427                         }
14428                         ndr->flags = _flags_save_string;
14429                 }
14430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14432         }
14433         if (ndr_flags & NDR_BUFFERS) {
14434         }
14435         return NDR_ERR_SUCCESS;
14436 }
14437
14438 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14439 {
14440         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14441         ndr->depth++;
14442         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
14443         ndr_print_uint32(ndr, "major", r->major);
14444         ndr_print_uint32(ndr, "minor", r->minor);
14445         ndr_print_uint32(ndr, "build", r->build);
14446         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14447         ndr_print_string(ndr, "extra_string", r->extra_string);
14448         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14449         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14450         ndr->depth--;
14451 }
14452
14453 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14454 {
14455         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14456 }
14457
14458 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
14459 {
14460         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14461         return NDR_ERR_SUCCESS;
14462 }
14463
14464 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
14465 {
14466         uint32_t v;
14467         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14468         *r = v;
14469         return NDR_ERR_SUCCESS;
14470 }
14471
14472 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
14473 {
14474         const char *val = NULL;
14475
14476         switch (r) {
14477                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
14478                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
14479                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
14480                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
14481                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
14482         }
14483         ndr_print_enum(ndr, name, "ENUM", val, r);
14484 }
14485
14486 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14487 {
14488         if (ndr_flags & NDR_SCALARS) {
14489                 int level = ndr_push_get_switch_value(ndr, r);
14490                 switch (level) {
14491                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14492                         break; }
14493
14494                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14495                                 {
14496                                         uint32_t _flags_save_string = ndr->flags;
14497                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14498                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14499                                         ndr->flags = _flags_save_string;
14500                                 }
14501                         break; }
14502
14503                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14504                                 {
14505                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14506                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14507                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14508                                         ndr->flags = _flags_save_DATA_BLOB;
14509                                 }
14510                         break; }
14511
14512                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14513                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14514                         break; }
14515
14516                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14517                                 {
14518                                         uint32_t _flags_save_string_array = ndr->flags;
14519                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14520                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14521                                         ndr->flags = _flags_save_string_array;
14522                                 }
14523                         break; }
14524
14525                         default: {
14526                                 {
14527                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14528                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14529                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14530                                         ndr->flags = _flags_save_DATA_BLOB;
14531                                 }
14532                         break; }
14533
14534                 }
14535         }
14536         if (ndr_flags & NDR_BUFFERS) {
14537                 int level = ndr_push_get_switch_value(ndr, r);
14538                 switch (level) {
14539                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14540                         break;
14541
14542                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14543                         break;
14544
14545                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14546                         break;
14547
14548                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14549                         break;
14550
14551                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14552                         break;
14553
14554                         default:
14555                         break;
14556
14557                 }
14558         }
14559         return NDR_ERR_SUCCESS;
14560 }
14561
14562 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14563 {
14564         int level;
14565         level = ndr_pull_get_switch_value(ndr, r);
14566         if (ndr_flags & NDR_SCALARS) {
14567                 switch (level) {
14568                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14569                         break; }
14570
14571                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14572                                 {
14573                                         uint32_t _flags_save_string = ndr->flags;
14574                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14575                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14576                                         ndr->flags = _flags_save_string;
14577                                 }
14578                         break; }
14579
14580                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14581                                 {
14582                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14583                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14584                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14585                                         ndr->flags = _flags_save_DATA_BLOB;
14586                                 }
14587                         break; }
14588
14589                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14590                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14591                         break; }
14592
14593                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14594                                 {
14595                                         uint32_t _flags_save_string_array = ndr->flags;
14596                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14597                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14598                                         ndr->flags = _flags_save_string_array;
14599                                 }
14600                         break; }
14601
14602                         default: {
14603                                 {
14604                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14605                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14606                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14607                                         ndr->flags = _flags_save_DATA_BLOB;
14608                                 }
14609                         break; }
14610
14611                 }
14612         }
14613         if (ndr_flags & NDR_BUFFERS) {
14614                 switch (level) {
14615                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14616                         break;
14617
14618                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14619                         break;
14620
14621                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14622                         break;
14623
14624                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14625                         break;
14626
14627                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14628                         break;
14629
14630                         default:
14631                         break;
14632
14633                 }
14634         }
14635         return NDR_ERR_SUCCESS;
14636 }
14637
14638 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14639 {
14640         int level;
14641         level = ndr_print_get_switch_value(ndr, r);
14642         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14643         switch (level) {
14644                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14645                 break;
14646
14647                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14648                         ndr_print_string(ndr, "string", r->string);
14649                 break;
14650
14651                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14652                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14653                 break;
14654
14655                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14656                         ndr_print_uint32(ndr, "value", r->value);
14657                 break;
14658
14659                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14660                         ndr_print_string_array(ndr, "string_array", r->string_array);
14661                 break;
14662
14663                 default:
14664                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14665                 break;
14666
14667         }
14668 }
14669
14670 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14671 {
14672         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14673 }
14674
14675 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14676 {
14677         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14678         return NDR_ERR_SUCCESS;
14679 }
14680
14681 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14682 {
14683         uint32_t v;
14684         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14685         *r = v;
14686         return NDR_ERR_SUCCESS;
14687 }
14688
14689 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14690 {
14691         const char *val = NULL;
14692
14693         switch (r) {
14694                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14695                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14696                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14697         }
14698         ndr_print_enum(ndr, name, "ENUM", val, r);
14699 }
14700
14701 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14702 {
14703         if (ndr_flags & NDR_SCALARS) {
14704                 NDR_CHECK(ndr_push_align(ndr, 4));
14705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14707         }
14708         if (ndr_flags & NDR_BUFFERS) {
14709         }
14710         return NDR_ERR_SUCCESS;
14711 }
14712
14713 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14714 {
14715         if (ndr_flags & NDR_SCALARS) {
14716                 NDR_CHECK(ndr_pull_align(ndr, 4));
14717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14719         }
14720         if (ndr_flags & NDR_BUFFERS) {
14721         }
14722         return NDR_ERR_SUCCESS;
14723 }
14724
14725 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14726 {
14727         ndr_print_struct(ndr, name, "spoolss_FormSize");
14728         ndr->depth++;
14729         ndr_print_uint32(ndr, "width", r->width);
14730         ndr_print_uint32(ndr, "height", r->height);
14731         ndr->depth--;
14732 }
14733
14734 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14735 {
14736         if (ndr_flags & NDR_SCALARS) {
14737                 NDR_CHECK(ndr_push_align(ndr, 4));
14738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14742         }
14743         if (ndr_flags & NDR_BUFFERS) {
14744         }
14745         return NDR_ERR_SUCCESS;
14746 }
14747
14748 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14749 {
14750         if (ndr_flags & NDR_SCALARS) {
14751                 NDR_CHECK(ndr_pull_align(ndr, 4));
14752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14756         }
14757         if (ndr_flags & NDR_BUFFERS) {
14758         }
14759         return NDR_ERR_SUCCESS;
14760 }
14761
14762 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14763 {
14764         ndr_print_struct(ndr, name, "spoolss_FormArea");
14765         ndr->depth++;
14766         ndr_print_uint32(ndr, "left", r->left);
14767         ndr_print_uint32(ndr, "top", r->top);
14768         ndr_print_uint32(ndr, "right", r->right);
14769         ndr_print_uint32(ndr, "bottom", r->bottom);
14770         ndr->depth--;
14771 }
14772
14773 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14774 {
14775         if (ndr_flags & NDR_SCALARS) {
14776                 NDR_CHECK(ndr_push_align(ndr, 4));
14777                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14778                 {
14779                         uint32_t _flags_save_string = ndr->flags;
14780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14782                         ndr->flags = _flags_save_string;
14783                 }
14784                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14785                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14786         }
14787         if (ndr_flags & NDR_BUFFERS) {
14788                 {
14789                         uint32_t _flags_save_string = ndr->flags;
14790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14791                         if (r->form_name) {
14792                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14793                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14794                         }
14795                         ndr->flags = _flags_save_string;
14796                 }
14797         }
14798         return NDR_ERR_SUCCESS;
14799 }
14800
14801 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14802 {
14803         uint32_t _ptr_form_name;
14804         TALLOC_CTX *_mem_save_form_name_0;
14805         if (ndr_flags & NDR_SCALARS) {
14806                 NDR_CHECK(ndr_pull_align(ndr, 4));
14807                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14808                 {
14809                         uint32_t _flags_save_string = ndr->flags;
14810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14812                         if (_ptr_form_name) {
14813                                 NDR_PULL_ALLOC(ndr, r->form_name);
14814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14815                         } else {
14816                                 r->form_name = NULL;
14817                         }
14818                         ndr->flags = _flags_save_string;
14819                 }
14820                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14821                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14822         }
14823         if (ndr_flags & NDR_BUFFERS) {
14824                 {
14825                         uint32_t _flags_save_string = ndr->flags;
14826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14827                         if (r->form_name) {
14828                                 uint32_t _relative_save_offset;
14829                                 _relative_save_offset = ndr->offset;
14830                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14831                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14832                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14833                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14834                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14835                                 ndr->offset = _relative_save_offset;
14836                         }
14837                         ndr->flags = _flags_save_string;
14838                 }
14839         }
14840         return NDR_ERR_SUCCESS;
14841 }
14842
14843 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14844 {
14845         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14846         ndr->depth++;
14847         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14848         ndr_print_ptr(ndr, "form_name", r->form_name);
14849         ndr->depth++;
14850         if (r->form_name) {
14851                 ndr_print_string(ndr, "form_name", r->form_name);
14852         }
14853         ndr->depth--;
14854         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14855         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14856         ndr->depth--;
14857 }
14858
14859 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14860 {
14861         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14862 }
14863
14864 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14865 {
14866         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14867         return NDR_ERR_SUCCESS;
14868 }
14869
14870 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14871 {
14872         uint32_t v;
14873         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14874         *r = v;
14875         return NDR_ERR_SUCCESS;
14876 }
14877
14878 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14879 {
14880         ndr_print_uint32(ndr, name, r);
14881         ndr->depth++;
14882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14885         ndr->depth--;
14886 }
14887
14888 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14889 {
14890         if (ndr_flags & NDR_SCALARS) {
14891                 NDR_CHECK(ndr_push_align(ndr, 4));
14892                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14893                 {
14894                         uint32_t _flags_save_string = ndr->flags;
14895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14896                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14897                         ndr->flags = _flags_save_string;
14898                 }
14899                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14900                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14901                 {
14902                         uint32_t _flags_save_string = ndr->flags;
14903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14904                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14905                         ndr->flags = _flags_save_string;
14906                 }
14907                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14908                 {
14909                         uint32_t _flags_save_string = ndr->flags;
14910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14911                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14912                         ndr->flags = _flags_save_string;
14913                 }
14914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14915                 {
14916                         uint32_t _flags_save_string = ndr->flags;
14917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14918                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
14919                         ndr->flags = _flags_save_string;
14920                 }
14921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14922         }
14923         if (ndr_flags & NDR_BUFFERS) {
14924                 {
14925                         uint32_t _flags_save_string = ndr->flags;
14926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14927                         if (r->form_name) {
14928                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14929                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14930                         }
14931                         ndr->flags = _flags_save_string;
14932                 }
14933                 {
14934                         uint32_t _flags_save_string = ndr->flags;
14935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14936                         if (r->keyword) {
14937                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
14938                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
14939                         }
14940                         ndr->flags = _flags_save_string;
14941                 }
14942                 {
14943                         uint32_t _flags_save_string = ndr->flags;
14944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14945                         if (r->mui_dll) {
14946                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
14947                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
14948                         }
14949                         ndr->flags = _flags_save_string;
14950                 }
14951                 {
14952                         uint32_t _flags_save_string = ndr->flags;
14953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14954                         if (r->display_name) {
14955                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
14956                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
14957                         }
14958                         ndr->flags = _flags_save_string;
14959                 }
14960         }
14961         return NDR_ERR_SUCCESS;
14962 }
14963
14964 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
14965 {
14966         uint32_t _ptr_form_name;
14967         TALLOC_CTX *_mem_save_form_name_0;
14968         uint32_t _ptr_keyword;
14969         TALLOC_CTX *_mem_save_keyword_0;
14970         uint32_t _ptr_mui_dll;
14971         TALLOC_CTX *_mem_save_mui_dll_0;
14972         uint32_t _ptr_display_name;
14973         TALLOC_CTX *_mem_save_display_name_0;
14974         if (ndr_flags & NDR_SCALARS) {
14975                 NDR_CHECK(ndr_pull_align(ndr, 4));
14976                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14977                 {
14978                         uint32_t _flags_save_string = ndr->flags;
14979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14980                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14981                         if (_ptr_form_name) {
14982                                 NDR_PULL_ALLOC(ndr, r->form_name);
14983                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14984                         } else {
14985                                 r->form_name = NULL;
14986                         }
14987                         ndr->flags = _flags_save_string;
14988                 }
14989                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14990                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14991                 {
14992                         uint32_t _flags_save_string = ndr->flags;
14993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14994                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
14995                         if (_ptr_keyword) {
14996                                 NDR_PULL_ALLOC(ndr, r->keyword);
14997                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
14998                         } else {
14999                                 r->keyword = NULL;
15000                         }
15001                         ndr->flags = _flags_save_string;
15002                 }
15003                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15004                 {
15005                         uint32_t _flags_save_string = ndr->flags;
15006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15007                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15008                         if (_ptr_mui_dll) {
15009                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15010                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15011                         } else {
15012                                 r->mui_dll = NULL;
15013                         }
15014                         ndr->flags = _flags_save_string;
15015                 }
15016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15017                 {
15018                         uint32_t _flags_save_string = ndr->flags;
15019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15020                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15021                         if (_ptr_display_name) {
15022                                 NDR_PULL_ALLOC(ndr, r->display_name);
15023                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15024                         } else {
15025                                 r->display_name = NULL;
15026                         }
15027                         ndr->flags = _flags_save_string;
15028                 }
15029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15030         }
15031         if (ndr_flags & NDR_BUFFERS) {
15032                 {
15033                         uint32_t _flags_save_string = ndr->flags;
15034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15035                         if (r->form_name) {
15036                                 uint32_t _relative_save_offset;
15037                                 _relative_save_offset = ndr->offset;
15038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15039                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15040                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15043                                 ndr->offset = _relative_save_offset;
15044                         }
15045                         ndr->flags = _flags_save_string;
15046                 }
15047                 {
15048                         uint32_t _flags_save_string = ndr->flags;
15049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15050                         if (r->keyword) {
15051                                 uint32_t _relative_save_offset;
15052                                 _relative_save_offset = ndr->offset;
15053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15054                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15055                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15058                                 ndr->offset = _relative_save_offset;
15059                         }
15060                         ndr->flags = _flags_save_string;
15061                 }
15062                 {
15063                         uint32_t _flags_save_string = ndr->flags;
15064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15065                         if (r->mui_dll) {
15066                                 uint32_t _relative_save_offset;
15067                                 _relative_save_offset = ndr->offset;
15068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15069                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15070                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15071                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15073                                 ndr->offset = _relative_save_offset;
15074                         }
15075                         ndr->flags = _flags_save_string;
15076                 }
15077                 {
15078                         uint32_t _flags_save_string = ndr->flags;
15079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15080                         if (r->display_name) {
15081                                 uint32_t _relative_save_offset;
15082                                 _relative_save_offset = ndr->offset;
15083                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15084                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15085                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15086                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15087                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15088                                 ndr->offset = _relative_save_offset;
15089                         }
15090                         ndr->flags = _flags_save_string;
15091                 }
15092         }
15093         return NDR_ERR_SUCCESS;
15094 }
15095
15096 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15097 {
15098         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15099         ndr->depth++;
15100         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15101         ndr_print_ptr(ndr, "form_name", r->form_name);
15102         ndr->depth++;
15103         if (r->form_name) {
15104                 ndr_print_string(ndr, "form_name", r->form_name);
15105         }
15106         ndr->depth--;
15107         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15108         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15109         ndr_print_ptr(ndr, "keyword", r->keyword);
15110         ndr->depth++;
15111         if (r->keyword) {
15112                 ndr_print_string(ndr, "keyword", r->keyword);
15113         }
15114         ndr->depth--;
15115         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15116         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15117         ndr->depth++;
15118         if (r->mui_dll) {
15119                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15120         }
15121         ndr->depth--;
15122         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15123         ndr_print_ptr(ndr, "display_name", r->display_name);
15124         ndr->depth++;
15125         if (r->display_name) {
15126                 ndr_print_string(ndr, "display_name", r->display_name);
15127         }
15128         ndr->depth--;
15129         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15130         ndr->depth--;
15131 }
15132
15133 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15134 {
15135         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15136 }
15137
15138 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15139 {
15140         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15141         if (ndr_flags & NDR_SCALARS) {
15142                 int level = ndr_push_get_switch_value(ndr, r);
15143                 switch (level) {
15144                         case 1: {
15145                                 NDR_CHECK(ndr_push_align(ndr, 4));
15146                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15147                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15148                         break; }
15149
15150                         case 2: {
15151                                 NDR_CHECK(ndr_push_align(ndr, 4));
15152                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15153                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15154                         break; }
15155
15156                         default: {
15157                         break; }
15158
15159                 }
15160         }
15161         if (ndr_flags & NDR_BUFFERS) {
15162                 int level = ndr_push_get_switch_value(ndr, r);
15163                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15164                 switch (level) {
15165                         case 1:
15166                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15167                         break;
15168
15169                         case 2:
15170                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15171                         break;
15172
15173                         default:
15174                         break;
15175
15176                 }
15177         }
15178         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15179         return NDR_ERR_SUCCESS;
15180 }
15181
15182 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15183 {
15184         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15185         int level;
15186         level = ndr_pull_get_switch_value(ndr, r);
15187         if (ndr_flags & NDR_SCALARS) {
15188                 switch (level) {
15189                         case 1: {
15190                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15191                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15192                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15193                         break; }
15194
15195                         case 2: {
15196                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15197                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15198                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15199                         break; }
15200
15201                         default: {
15202                         break; }
15203
15204                 }
15205         }
15206         if (ndr_flags & NDR_BUFFERS) {
15207                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15208                 switch (level) {
15209                         case 1:
15210                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15211                         break;
15212
15213                         case 2:
15214                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15215                         break;
15216
15217                         default:
15218                         break;
15219
15220                 }
15221         }
15222         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15223         return NDR_ERR_SUCCESS;
15224 }
15225
15226 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15227 {
15228         int level;
15229         level = ndr_print_get_switch_value(ndr, r);
15230         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15231         switch (level) {
15232                 case 1:
15233                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15234                 break;
15235
15236                 case 2:
15237                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15238                 break;
15239
15240                 default:
15241                 break;
15242
15243         }
15244 }
15245
15246 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15247 {
15248         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15249 }
15250
15251 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15252 {
15253         if (ndr_flags & NDR_SCALARS) {
15254                 NDR_CHECK(ndr_push_align(ndr, 4));
15255                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15257                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15258                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15259         }
15260         if (ndr_flags & NDR_BUFFERS) {
15261                 if (r->form_name) {
15262                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15265                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15266                 }
15267         }
15268         return NDR_ERR_SUCCESS;
15269 }
15270
15271 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15272 {
15273         uint32_t _ptr_form_name;
15274         TALLOC_CTX *_mem_save_form_name_0;
15275         if (ndr_flags & NDR_SCALARS) {
15276                 NDR_CHECK(ndr_pull_align(ndr, 4));
15277                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15279                 if (_ptr_form_name) {
15280                         NDR_PULL_ALLOC(ndr, r->form_name);
15281                 } else {
15282                         r->form_name = NULL;
15283                 }
15284                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15285                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15286         }
15287         if (ndr_flags & NDR_BUFFERS) {
15288                 if (r->form_name) {
15289                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15290                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15291                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15292                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15293                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15294                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
15295                         }
15296                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15297                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15299                 }
15300         }
15301         return NDR_ERR_SUCCESS;
15302 }
15303
15304 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15305 {
15306         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15307         ndr->depth++;
15308         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15309         ndr_print_ptr(ndr, "form_name", r->form_name);
15310         ndr->depth++;
15311         if (r->form_name) {
15312                 ndr_print_string(ndr, "form_name", r->form_name);
15313         }
15314         ndr->depth--;
15315         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15316         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15317         ndr->depth--;
15318 }
15319
15320 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15321 {
15322         if (ndr_flags & NDR_SCALARS) {
15323                 NDR_CHECK(ndr_push_align(ndr, 4));
15324                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15326                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15327                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15329                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15332                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15334         }
15335         if (ndr_flags & NDR_BUFFERS) {
15336                 if (r->form_name) {
15337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15341                 }
15342                 if (r->keyword) {
15343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15346                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15347                 }
15348                 if (r->mui_dll) {
15349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15352                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15353                 }
15354                 if (r->display_name) {
15355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15358                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15359                 }
15360         }
15361         return NDR_ERR_SUCCESS;
15362 }
15363
15364 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15365 {
15366         uint32_t _ptr_form_name;
15367         TALLOC_CTX *_mem_save_form_name_0;
15368         uint32_t _ptr_keyword;
15369         TALLOC_CTX *_mem_save_keyword_0;
15370         uint32_t _ptr_mui_dll;
15371         TALLOC_CTX *_mem_save_mui_dll_0;
15372         uint32_t _ptr_display_name;
15373         TALLOC_CTX *_mem_save_display_name_0;
15374         if (ndr_flags & NDR_SCALARS) {
15375                 NDR_CHECK(ndr_pull_align(ndr, 4));
15376                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15378                 if (_ptr_form_name) {
15379                         NDR_PULL_ALLOC(ndr, r->form_name);
15380                 } else {
15381                         r->form_name = NULL;
15382                 }
15383                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15384                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15386                 if (_ptr_keyword) {
15387                         NDR_PULL_ALLOC(ndr, r->keyword);
15388                 } else {
15389                         r->keyword = NULL;
15390                 }
15391                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15393                 if (_ptr_mui_dll) {
15394                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15395                 } else {
15396                         r->mui_dll = NULL;
15397                 }
15398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15399                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15400                 if (_ptr_display_name) {
15401                         NDR_PULL_ALLOC(ndr, r->display_name);
15402                 } else {
15403                         r->display_name = NULL;
15404                 }
15405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15406         }
15407         if (ndr_flags & NDR_BUFFERS) {
15408                 if (r->form_name) {
15409                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15410                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15411                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15412                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15413                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15414                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
15415                         }
15416                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15417                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15418                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15419                 }
15420                 if (r->keyword) {
15421                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15422                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15423                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15424                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15425                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15426                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->keyword), ndr_get_array_length(ndr, &r->keyword));
15427                         }
15428                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15429                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15430                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15431                 }
15432                 if (r->mui_dll) {
15433                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15434                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15435                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15436                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15437                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15438                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->mui_dll), ndr_get_array_length(ndr, &r->mui_dll));
15439                         }
15440                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15441                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15442                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15443                 }
15444                 if (r->display_name) {
15445                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15446                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15449                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15450                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->display_name), ndr_get_array_length(ndr, &r->display_name));
15451                         }
15452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15455                 }
15456         }
15457         return NDR_ERR_SUCCESS;
15458 }
15459
15460 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15461 {
15462         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15463         ndr->depth++;
15464         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15465         ndr_print_ptr(ndr, "form_name", r->form_name);
15466         ndr->depth++;
15467         if (r->form_name) {
15468                 ndr_print_string(ndr, "form_name", r->form_name);
15469         }
15470         ndr->depth--;
15471         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15472         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15473         ndr_print_ptr(ndr, "keyword", r->keyword);
15474         ndr->depth++;
15475         if (r->keyword) {
15476                 ndr_print_string(ndr, "keyword", r->keyword);
15477         }
15478         ndr->depth--;
15479         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15480         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15481         ndr->depth++;
15482         if (r->mui_dll) {
15483                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15484         }
15485         ndr->depth--;
15486         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15487         ndr_print_ptr(ndr, "display_name", r->display_name);
15488         ndr->depth++;
15489         if (r->display_name) {
15490                 ndr_print_string(ndr, "display_name", r->display_name);
15491         }
15492         ndr->depth--;
15493         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15494         ndr->depth--;
15495 }
15496
15497 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15498 {
15499         if (ndr_flags & NDR_SCALARS) {
15500                 int level = ndr_push_get_switch_value(ndr, r);
15501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15502                 switch (level) {
15503                         case 1: {
15504                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15505                         break; }
15506
15507                         case 2: {
15508                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15509                         break; }
15510
15511                         default:
15512                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15513                 }
15514         }
15515         if (ndr_flags & NDR_BUFFERS) {
15516                 int level = ndr_push_get_switch_value(ndr, r);
15517                 switch (level) {
15518                         case 1:
15519                                 if (r->info1) {
15520                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15521                                 }
15522                         break;
15523
15524                         case 2:
15525                                 if (r->info2) {
15526                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15527                                 }
15528                         break;
15529
15530                         default:
15531                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15532                 }
15533         }
15534         return NDR_ERR_SUCCESS;
15535 }
15536
15537 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15538 {
15539         int level;
15540         uint32_t _level;
15541         TALLOC_CTX *_mem_save_info1_0;
15542         TALLOC_CTX *_mem_save_info2_0;
15543         level = ndr_pull_get_switch_value(ndr, r);
15544         if (ndr_flags & NDR_SCALARS) {
15545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15546                 if (_level != level) {
15547                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15548                 }
15549                 switch (level) {
15550                         case 1: {
15551                                 uint32_t _ptr_info1;
15552                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15553                                 if (_ptr_info1) {
15554                                         NDR_PULL_ALLOC(ndr, r->info1);
15555                                 } else {
15556                                         r->info1 = NULL;
15557                                 }
15558                         break; }
15559
15560                         case 2: {
15561                                 uint32_t _ptr_info2;
15562                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15563                                 if (_ptr_info2) {
15564                                         NDR_PULL_ALLOC(ndr, r->info2);
15565                                 } else {
15566                                         r->info2 = NULL;
15567                                 }
15568                         break; }
15569
15570                         default:
15571                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15572                 }
15573         }
15574         if (ndr_flags & NDR_BUFFERS) {
15575                 switch (level) {
15576                         case 1:
15577                                 if (r->info1) {
15578                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15579                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15580                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15581                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15582                                 }
15583                         break;
15584
15585                         case 2:
15586                                 if (r->info2) {
15587                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15588                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15589                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15590                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15591                                 }
15592                         break;
15593
15594                         default:
15595                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15596                 }
15597         }
15598         return NDR_ERR_SUCCESS;
15599 }
15600
15601 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15602 {
15603         int level;
15604         level = ndr_print_get_switch_value(ndr, r);
15605         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15606         switch (level) {
15607                 case 1:
15608                         ndr_print_ptr(ndr, "info1", r->info1);
15609                         ndr->depth++;
15610                         if (r->info1) {
15611                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15612                         }
15613                         ndr->depth--;
15614                 break;
15615
15616                 case 2:
15617                         ndr_print_ptr(ndr, "info2", r->info2);
15618                         ndr->depth++;
15619                         if (r->info2) {
15620                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15621                         }
15622                         ndr->depth--;
15623                 break;
15624
15625                 default:
15626                         ndr_print_bad_level(ndr, name, level);
15627         }
15628 }
15629
15630 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15631 {
15632         if (ndr_flags & NDR_SCALARS) {
15633                 NDR_CHECK(ndr_push_align(ndr, 4));
15634                 {
15635                         uint32_t _flags_save_string = ndr->flags;
15636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15638                         ndr->flags = _flags_save_string;
15639                 }
15640         }
15641         if (ndr_flags & NDR_BUFFERS) {
15642                 {
15643                         uint32_t _flags_save_string = ndr->flags;
15644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15645                         if (r->port_name) {
15646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15648                         }
15649                         ndr->flags = _flags_save_string;
15650                 }
15651         }
15652         return NDR_ERR_SUCCESS;
15653 }
15654
15655 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15656 {
15657         uint32_t _ptr_port_name;
15658         TALLOC_CTX *_mem_save_port_name_0;
15659         if (ndr_flags & NDR_SCALARS) {
15660                 NDR_CHECK(ndr_pull_align(ndr, 4));
15661                 {
15662                         uint32_t _flags_save_string = ndr->flags;
15663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15664                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15665                         if (_ptr_port_name) {
15666                                 NDR_PULL_ALLOC(ndr, r->port_name);
15667                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15668                         } else {
15669                                 r->port_name = NULL;
15670                         }
15671                         ndr->flags = _flags_save_string;
15672                 }
15673         }
15674         if (ndr_flags & NDR_BUFFERS) {
15675                 {
15676                         uint32_t _flags_save_string = ndr->flags;
15677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15678                         if (r->port_name) {
15679                                 uint32_t _relative_save_offset;
15680                                 _relative_save_offset = ndr->offset;
15681                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15682                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15683                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15684                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15685                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15686                                 ndr->offset = _relative_save_offset;
15687                         }
15688                         ndr->flags = _flags_save_string;
15689                 }
15690         }
15691         return NDR_ERR_SUCCESS;
15692 }
15693
15694 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15695 {
15696         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15697         ndr->depth++;
15698         ndr_print_ptr(ndr, "port_name", r->port_name);
15699         ndr->depth++;
15700         if (r->port_name) {
15701                 ndr_print_string(ndr, "port_name", r->port_name);
15702         }
15703         ndr->depth--;
15704         ndr->depth--;
15705 }
15706
15707 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15708 {
15709         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15710 }
15711
15712 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15713 {
15714         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15715         return NDR_ERR_SUCCESS;
15716 }
15717
15718 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15719 {
15720         uint32_t v;
15721         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15722         *r = v;
15723         return NDR_ERR_SUCCESS;
15724 }
15725
15726 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15727 {
15728         ndr_print_uint32(ndr, name, r);
15729         ndr->depth++;
15730         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15731         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15732         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15733         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15734         ndr->depth--;
15735 }
15736
15737 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15738 {
15739         if (ndr_flags & NDR_SCALARS) {
15740                 NDR_CHECK(ndr_push_align(ndr, 4));
15741                 {
15742                         uint32_t _flags_save_string = ndr->flags;
15743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15745                         ndr->flags = _flags_save_string;
15746                 }
15747                 {
15748                         uint32_t _flags_save_string = ndr->flags;
15749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15751                         ndr->flags = _flags_save_string;
15752                 }
15753                 {
15754                         uint32_t _flags_save_string = ndr->flags;
15755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15756                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15757                         ndr->flags = _flags_save_string;
15758                 }
15759                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15761         }
15762         if (ndr_flags & NDR_BUFFERS) {
15763                 {
15764                         uint32_t _flags_save_string = ndr->flags;
15765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15766                         if (r->port_name) {
15767                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15768                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15769                         }
15770                         ndr->flags = _flags_save_string;
15771                 }
15772                 {
15773                         uint32_t _flags_save_string = ndr->flags;
15774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15775                         if (r->monitor_name) {
15776                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15777                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15778                         }
15779                         ndr->flags = _flags_save_string;
15780                 }
15781                 {
15782                         uint32_t _flags_save_string = ndr->flags;
15783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15784                         if (r->description) {
15785                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15786                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15787                         }
15788                         ndr->flags = _flags_save_string;
15789                 }
15790         }
15791         return NDR_ERR_SUCCESS;
15792 }
15793
15794 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15795 {
15796         uint32_t _ptr_port_name;
15797         TALLOC_CTX *_mem_save_port_name_0;
15798         uint32_t _ptr_monitor_name;
15799         TALLOC_CTX *_mem_save_monitor_name_0;
15800         uint32_t _ptr_description;
15801         TALLOC_CTX *_mem_save_description_0;
15802         if (ndr_flags & NDR_SCALARS) {
15803                 NDR_CHECK(ndr_pull_align(ndr, 4));
15804                 {
15805                         uint32_t _flags_save_string = ndr->flags;
15806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15807                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15808                         if (_ptr_port_name) {
15809                                 NDR_PULL_ALLOC(ndr, r->port_name);
15810                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15811                         } else {
15812                                 r->port_name = NULL;
15813                         }
15814                         ndr->flags = _flags_save_string;
15815                 }
15816                 {
15817                         uint32_t _flags_save_string = ndr->flags;
15818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15819                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15820                         if (_ptr_monitor_name) {
15821                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15822                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15823                         } else {
15824                                 r->monitor_name = NULL;
15825                         }
15826                         ndr->flags = _flags_save_string;
15827                 }
15828                 {
15829                         uint32_t _flags_save_string = ndr->flags;
15830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15832                         if (_ptr_description) {
15833                                 NDR_PULL_ALLOC(ndr, r->description);
15834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15835                         } else {
15836                                 r->description = NULL;
15837                         }
15838                         ndr->flags = _flags_save_string;
15839                 }
15840                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15842         }
15843         if (ndr_flags & NDR_BUFFERS) {
15844                 {
15845                         uint32_t _flags_save_string = ndr->flags;
15846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15847                         if (r->port_name) {
15848                                 uint32_t _relative_save_offset;
15849                                 _relative_save_offset = ndr->offset;
15850                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15851                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15852                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15853                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15854                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15855                                 ndr->offset = _relative_save_offset;
15856                         }
15857                         ndr->flags = _flags_save_string;
15858                 }
15859                 {
15860                         uint32_t _flags_save_string = ndr->flags;
15861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15862                         if (r->monitor_name) {
15863                                 uint32_t _relative_save_offset;
15864                                 _relative_save_offset = ndr->offset;
15865                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15866                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15867                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15868                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15869                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15870                                 ndr->offset = _relative_save_offset;
15871                         }
15872                         ndr->flags = _flags_save_string;
15873                 }
15874                 {
15875                         uint32_t _flags_save_string = ndr->flags;
15876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15877                         if (r->description) {
15878                                 uint32_t _relative_save_offset;
15879                                 _relative_save_offset = ndr->offset;
15880                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15881                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15882                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15883                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15884                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15885                                 ndr->offset = _relative_save_offset;
15886                         }
15887                         ndr->flags = _flags_save_string;
15888                 }
15889         }
15890         return NDR_ERR_SUCCESS;
15891 }
15892
15893 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15894 {
15895         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15896         ndr->depth++;
15897         ndr_print_ptr(ndr, "port_name", r->port_name);
15898         ndr->depth++;
15899         if (r->port_name) {
15900                 ndr_print_string(ndr, "port_name", r->port_name);
15901         }
15902         ndr->depth--;
15903         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15904         ndr->depth++;
15905         if (r->monitor_name) {
15906                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15907         }
15908         ndr->depth--;
15909         ndr_print_ptr(ndr, "description", r->description);
15910         ndr->depth++;
15911         if (r->description) {
15912                 ndr_print_string(ndr, "description", r->description);
15913         }
15914         ndr->depth--;
15915         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15916         ndr_print_uint32(ndr, "reserved", r->reserved);
15917         ndr->depth--;
15918 }
15919
15920 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15921 {
15922         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
15923 }
15924
15925 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
15926 {
15927         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15928         return NDR_ERR_SUCCESS;
15929 }
15930
15931 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
15932 {
15933         uint32_t v;
15934         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15935         *r = v;
15936         return NDR_ERR_SUCCESS;
15937 }
15938
15939 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
15940 {
15941         const char *val = NULL;
15942
15943         switch (r) {
15944                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
15945                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
15946                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
15947                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
15948                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
15949                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
15950                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
15951                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
15952                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
15953                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
15954                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
15955                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
15956                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
15957         }
15958         ndr_print_enum(ndr, name, "ENUM", val, r);
15959 }
15960
15961 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
15962 {
15963         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15964         return NDR_ERR_SUCCESS;
15965 }
15966
15967 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
15968 {
15969         uint32_t v;
15970         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15971         *r = v;
15972         return NDR_ERR_SUCCESS;
15973 }
15974
15975 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
15976 {
15977         const char *val = NULL;
15978
15979         switch (r) {
15980                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
15981                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
15982                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
15983         }
15984         ndr_print_enum(ndr, name, "ENUM", val, r);
15985 }
15986
15987 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
15988 {
15989         if (ndr_flags & NDR_SCALARS) {
15990                 NDR_CHECK(ndr_push_align(ndr, 4));
15991                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
15992                 {
15993                         uint32_t _flags_save_string = ndr->flags;
15994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
15996                         ndr->flags = _flags_save_string;
15997                 }
15998                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
15999         }
16000         if (ndr_flags & NDR_BUFFERS) {
16001                 {
16002                         uint32_t _flags_save_string = ndr->flags;
16003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16004                         if (r->status_string) {
16005                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16007                         }
16008                         ndr->flags = _flags_save_string;
16009                 }
16010         }
16011         return NDR_ERR_SUCCESS;
16012 }
16013
16014 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16015 {
16016         uint32_t _ptr_status_string;
16017         TALLOC_CTX *_mem_save_status_string_0;
16018         if (ndr_flags & NDR_SCALARS) {
16019                 NDR_CHECK(ndr_pull_align(ndr, 4));
16020                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16021                 {
16022                         uint32_t _flags_save_string = ndr->flags;
16023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16024                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16025                         if (_ptr_status_string) {
16026                                 NDR_PULL_ALLOC(ndr, r->status_string);
16027                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16028                         } else {
16029                                 r->status_string = NULL;
16030                         }
16031                         ndr->flags = _flags_save_string;
16032                 }
16033                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16034         }
16035         if (ndr_flags & NDR_BUFFERS) {
16036                 {
16037                         uint32_t _flags_save_string = ndr->flags;
16038                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16039                         if (r->status_string) {
16040                                 uint32_t _relative_save_offset;
16041                                 _relative_save_offset = ndr->offset;
16042                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16043                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16044                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16045                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16046                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16047                                 ndr->offset = _relative_save_offset;
16048                         }
16049                         ndr->flags = _flags_save_string;
16050                 }
16051         }
16052         return NDR_ERR_SUCCESS;
16053 }
16054
16055 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16056 {
16057         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16058         ndr->depth++;
16059         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16060         ndr_print_ptr(ndr, "status_string", r->status_string);
16061         ndr->depth++;
16062         if (r->status_string) {
16063                 ndr_print_string(ndr, "status_string", r->status_string);
16064         }
16065         ndr->depth--;
16066         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16067         ndr->depth--;
16068 }
16069
16070 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16071 {
16072         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16073 }
16074
16075 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16076 {
16077         if (ndr_flags & NDR_SCALARS) {
16078                 NDR_CHECK(ndr_push_align(ndr, 4));
16079                 {
16080                         uint32_t _flags_save_string = ndr->flags;
16081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16082                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16083                         ndr->flags = _flags_save_string;
16084                 }
16085                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16086         }
16087         if (ndr_flags & NDR_BUFFERS) {
16088                 {
16089                         uint32_t _flags_save_string = ndr->flags;
16090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16091                         if (r->port_name) {
16092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16094                         }
16095                         ndr->flags = _flags_save_string;
16096                 }
16097         }
16098         return NDR_ERR_SUCCESS;
16099 }
16100
16101 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16102 {
16103         uint32_t _ptr_port_name;
16104         TALLOC_CTX *_mem_save_port_name_0;
16105         if (ndr_flags & NDR_SCALARS) {
16106                 NDR_CHECK(ndr_pull_align(ndr, 4));
16107                 {
16108                         uint32_t _flags_save_string = ndr->flags;
16109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16110                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16111                         if (_ptr_port_name) {
16112                                 NDR_PULL_ALLOC(ndr, r->port_name);
16113                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16114                         } else {
16115                                 r->port_name = NULL;
16116                         }
16117                         ndr->flags = _flags_save_string;
16118                 }
16119                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16120         }
16121         if (ndr_flags & NDR_BUFFERS) {
16122                 {
16123                         uint32_t _flags_save_string = ndr->flags;
16124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16125                         if (r->port_name) {
16126                                 uint32_t _relative_save_offset;
16127                                 _relative_save_offset = ndr->offset;
16128                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16129                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16130                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16131                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16132                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16133                                 ndr->offset = _relative_save_offset;
16134                         }
16135                         ndr->flags = _flags_save_string;
16136                 }
16137         }
16138         return NDR_ERR_SUCCESS;
16139 }
16140
16141 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16142 {
16143         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16144         ndr->depth++;
16145         ndr_print_ptr(ndr, "port_name", r->port_name);
16146         ndr->depth++;
16147         if (r->port_name) {
16148                 ndr_print_string(ndr, "port_name", r->port_name);
16149         }
16150         ndr->depth--;
16151         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16152         ndr->depth--;
16153 }
16154
16155 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16156 {
16157         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16158 }
16159
16160 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16161 {
16162         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16163         if (ndr_flags & NDR_SCALARS) {
16164                 int level = ndr_push_get_switch_value(ndr, r);
16165                 switch (level) {
16166                         case 1: {
16167                                 NDR_CHECK(ndr_push_align(ndr, 4));
16168                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16169                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16170                         break; }
16171
16172                         case 2: {
16173                                 NDR_CHECK(ndr_push_align(ndr, 4));
16174                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16175                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16176                         break; }
16177
16178                         case 3: {
16179                                 NDR_CHECK(ndr_push_align(ndr, 4));
16180                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16181                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16182                         break; }
16183
16184                         case 0xff: {
16185                                 NDR_CHECK(ndr_push_align(ndr, 4));
16186                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16187                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16188                         break; }
16189
16190                         default: {
16191                         break; }
16192
16193                 }
16194         }
16195         if (ndr_flags & NDR_BUFFERS) {
16196                 int level = ndr_push_get_switch_value(ndr, r);
16197                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16198                 switch (level) {
16199                         case 1:
16200                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16201                         break;
16202
16203                         case 2:
16204                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16205                         break;
16206
16207                         case 3:
16208                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16209                         break;
16210
16211                         case 0xff:
16212                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16213                         break;
16214
16215                         default:
16216                         break;
16217
16218                 }
16219         }
16220         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16221         return NDR_ERR_SUCCESS;
16222 }
16223
16224 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16225 {
16226         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16227         int level;
16228         level = ndr_pull_get_switch_value(ndr, r);
16229         if (ndr_flags & NDR_SCALARS) {
16230                 switch (level) {
16231                         case 1: {
16232                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16233                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16234                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16235                         break; }
16236
16237                         case 2: {
16238                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16239                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16240                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16241                         break; }
16242
16243                         case 3: {
16244                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16245                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16246                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16247                         break; }
16248
16249                         case 0xff: {
16250                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16251                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16252                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16253                         break; }
16254
16255                         default: {
16256                         break; }
16257
16258                 }
16259         }
16260         if (ndr_flags & NDR_BUFFERS) {
16261                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16262                 switch (level) {
16263                         case 1:
16264                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16265                         break;
16266
16267                         case 2:
16268                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16269                         break;
16270
16271                         case 3:
16272                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16273                         break;
16274
16275                         case 0xff:
16276                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16277                         break;
16278
16279                         default:
16280                         break;
16281
16282                 }
16283         }
16284         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16285         return NDR_ERR_SUCCESS;
16286 }
16287
16288 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16289 {
16290         int level;
16291         level = ndr_print_get_switch_value(ndr, r);
16292         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16293         switch (level) {
16294                 case 1:
16295                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16296                 break;
16297
16298                 case 2:
16299                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16300                 break;
16301
16302                 case 3:
16303                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16304                 break;
16305
16306                 case 0xff:
16307                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16308                 break;
16309
16310                 default:
16311                 break;
16312
16313         }
16314 }
16315
16316 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16317 {
16318         if (ndr_flags & NDR_SCALARS) {
16319                 NDR_CHECK(ndr_push_align(ndr, 4));
16320                 {
16321                         uint32_t _flags_save_string = ndr->flags;
16322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16323                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16324                         ndr->flags = _flags_save_string;
16325                 }
16326         }
16327         if (ndr_flags & NDR_BUFFERS) {
16328                 {
16329                         uint32_t _flags_save_string = ndr->flags;
16330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16331                         if (r->monitor_name) {
16332                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16333                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16334                         }
16335                         ndr->flags = _flags_save_string;
16336                 }
16337         }
16338         return NDR_ERR_SUCCESS;
16339 }
16340
16341 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16342 {
16343         uint32_t _ptr_monitor_name;
16344         TALLOC_CTX *_mem_save_monitor_name_0;
16345         if (ndr_flags & NDR_SCALARS) {
16346                 NDR_CHECK(ndr_pull_align(ndr, 4));
16347                 {
16348                         uint32_t _flags_save_string = ndr->flags;
16349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16350                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16351                         if (_ptr_monitor_name) {
16352                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16353                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16354                         } else {
16355                                 r->monitor_name = NULL;
16356                         }
16357                         ndr->flags = _flags_save_string;
16358                 }
16359         }
16360         if (ndr_flags & NDR_BUFFERS) {
16361                 {
16362                         uint32_t _flags_save_string = ndr->flags;
16363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16364                         if (r->monitor_name) {
16365                                 uint32_t _relative_save_offset;
16366                                 _relative_save_offset = ndr->offset;
16367                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16368                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16369                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16370                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16371                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16372                                 ndr->offset = _relative_save_offset;
16373                         }
16374                         ndr->flags = _flags_save_string;
16375                 }
16376         }
16377         return NDR_ERR_SUCCESS;
16378 }
16379
16380 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16381 {
16382         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16383         ndr->depth++;
16384         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16385         ndr->depth++;
16386         if (r->monitor_name) {
16387                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16388         }
16389         ndr->depth--;
16390         ndr->depth--;
16391 }
16392
16393 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16394 {
16395         if (ndr_flags & NDR_SCALARS) {
16396                 NDR_CHECK(ndr_push_align(ndr, 4));
16397                 {
16398                         uint32_t _flags_save_string = ndr->flags;
16399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16400                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16401                         ndr->flags = _flags_save_string;
16402                 }
16403                 {
16404                         uint32_t _flags_save_string = ndr->flags;
16405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16406                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16407                         ndr->flags = _flags_save_string;
16408                 }
16409                 {
16410                         uint32_t _flags_save_string = ndr->flags;
16411                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16412                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16413                         ndr->flags = _flags_save_string;
16414                 }
16415         }
16416         if (ndr_flags & NDR_BUFFERS) {
16417                 {
16418                         uint32_t _flags_save_string = ndr->flags;
16419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16420                         if (r->monitor_name) {
16421                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16422                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16423                         }
16424                         ndr->flags = _flags_save_string;
16425                 }
16426                 {
16427                         uint32_t _flags_save_string = ndr->flags;
16428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16429                         if (r->environment) {
16430                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16431                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
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                         if (r->dll_name) {
16439                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16440                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16441                         }
16442                         ndr->flags = _flags_save_string;
16443                 }
16444         }
16445         return NDR_ERR_SUCCESS;
16446 }
16447
16448 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16449 {
16450         uint32_t _ptr_monitor_name;
16451         TALLOC_CTX *_mem_save_monitor_name_0;
16452         uint32_t _ptr_environment;
16453         TALLOC_CTX *_mem_save_environment_0;
16454         uint32_t _ptr_dll_name;
16455         TALLOC_CTX *_mem_save_dll_name_0;
16456         if (ndr_flags & NDR_SCALARS) {
16457                 NDR_CHECK(ndr_pull_align(ndr, 4));
16458                 {
16459                         uint32_t _flags_save_string = ndr->flags;
16460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16461                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16462                         if (_ptr_monitor_name) {
16463                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16464                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16465                         } else {
16466                                 r->monitor_name = NULL;
16467                         }
16468                         ndr->flags = _flags_save_string;
16469                 }
16470                 {
16471                         uint32_t _flags_save_string = ndr->flags;
16472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16473                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16474                         if (_ptr_environment) {
16475                                 NDR_PULL_ALLOC(ndr, r->environment);
16476                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16477                         } else {
16478                                 r->environment = NULL;
16479                         }
16480                         ndr->flags = _flags_save_string;
16481                 }
16482                 {
16483                         uint32_t _flags_save_string = ndr->flags;
16484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16485                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16486                         if (_ptr_dll_name) {
16487                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16488                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16489                         } else {
16490                                 r->dll_name = NULL;
16491                         }
16492                         ndr->flags = _flags_save_string;
16493                 }
16494         }
16495         if (ndr_flags & NDR_BUFFERS) {
16496                 {
16497                         uint32_t _flags_save_string = ndr->flags;
16498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16499                         if (r->monitor_name) {
16500                                 uint32_t _relative_save_offset;
16501                                 _relative_save_offset = ndr->offset;
16502                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16503                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16504                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16505                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16506                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16507                                 ndr->offset = _relative_save_offset;
16508                         }
16509                         ndr->flags = _flags_save_string;
16510                 }
16511                 {
16512                         uint32_t _flags_save_string = ndr->flags;
16513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16514                         if (r->environment) {
16515                                 uint32_t _relative_save_offset;
16516                                 _relative_save_offset = ndr->offset;
16517                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16518                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16519                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16520                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16521                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16522                                 ndr->offset = _relative_save_offset;
16523                         }
16524                         ndr->flags = _flags_save_string;
16525                 }
16526                 {
16527                         uint32_t _flags_save_string = ndr->flags;
16528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16529                         if (r->dll_name) {
16530                                 uint32_t _relative_save_offset;
16531                                 _relative_save_offset = ndr->offset;
16532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16533                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16534                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16535                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16537                                 ndr->offset = _relative_save_offset;
16538                         }
16539                         ndr->flags = _flags_save_string;
16540                 }
16541         }
16542         return NDR_ERR_SUCCESS;
16543 }
16544
16545 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16546 {
16547         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16548         ndr->depth++;
16549         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16550         ndr->depth++;
16551         if (r->monitor_name) {
16552                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16553         }
16554         ndr->depth--;
16555         ndr_print_ptr(ndr, "environment", r->environment);
16556         ndr->depth++;
16557         if (r->environment) {
16558                 ndr_print_string(ndr, "environment", r->environment);
16559         }
16560         ndr->depth--;
16561         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16562         ndr->depth++;
16563         if (r->dll_name) {
16564                 ndr_print_string(ndr, "dll_name", r->dll_name);
16565         }
16566         ndr->depth--;
16567         ndr->depth--;
16568 }
16569
16570 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16571 {
16572         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16573         if (ndr_flags & NDR_SCALARS) {
16574                 int level = ndr_push_get_switch_value(ndr, r);
16575                 switch (level) {
16576                         case 1: {
16577                                 NDR_CHECK(ndr_push_align(ndr, 4));
16578                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16579                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16580                         break; }
16581
16582                         case 2: {
16583                                 NDR_CHECK(ndr_push_align(ndr, 4));
16584                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16585                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16586                         break; }
16587
16588                         default: {
16589                         break; }
16590
16591                 }
16592         }
16593         if (ndr_flags & NDR_BUFFERS) {
16594                 int level = ndr_push_get_switch_value(ndr, r);
16595                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16596                 switch (level) {
16597                         case 1:
16598                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16599                         break;
16600
16601                         case 2:
16602                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16603                         break;
16604
16605                         default:
16606                         break;
16607
16608                 }
16609         }
16610         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16611         return NDR_ERR_SUCCESS;
16612 }
16613
16614 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16615 {
16616         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16617         int level;
16618         level = ndr_pull_get_switch_value(ndr, r);
16619         if (ndr_flags & NDR_SCALARS) {
16620                 switch (level) {
16621                         case 1: {
16622                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16623                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16624                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16625                         break; }
16626
16627                         case 2: {
16628                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16629                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16630                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16631                         break; }
16632
16633                         default: {
16634                         break; }
16635
16636                 }
16637         }
16638         if (ndr_flags & NDR_BUFFERS) {
16639                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16640                 switch (level) {
16641                         case 1:
16642                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16643                         break;
16644
16645                         case 2:
16646                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16647                         break;
16648
16649                         default:
16650                         break;
16651
16652                 }
16653         }
16654         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16655         return NDR_ERR_SUCCESS;
16656 }
16657
16658 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16659 {
16660         int level;
16661         level = ndr_print_get_switch_value(ndr, r);
16662         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16663         switch (level) {
16664                 case 1:
16665                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16666                 break;
16667
16668                 case 2:
16669                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16670                 break;
16671
16672                 default:
16673                 break;
16674
16675         }
16676 }
16677
16678 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16679 {
16680         if (ndr_flags & NDR_SCALARS) {
16681                 NDR_CHECK(ndr_push_align(ndr, 4));
16682                 {
16683                         uint32_t _flags_save_string = ndr->flags;
16684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16685                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16686                         ndr->flags = _flags_save_string;
16687                 }
16688         }
16689         if (ndr_flags & NDR_BUFFERS) {
16690                 {
16691                         uint32_t _flags_save_string = ndr->flags;
16692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16693                         if (r->name_array) {
16694                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16695                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16696                         }
16697                         ndr->flags = _flags_save_string;
16698                 }
16699         }
16700         return NDR_ERR_SUCCESS;
16701 }
16702
16703 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16704 {
16705         uint32_t _ptr_name_array;
16706         TALLOC_CTX *_mem_save_name_array_0;
16707         if (ndr_flags & NDR_SCALARS) {
16708                 NDR_CHECK(ndr_pull_align(ndr, 4));
16709                 {
16710                         uint32_t _flags_save_string = ndr->flags;
16711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16712                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16713                         if (_ptr_name_array) {
16714                                 NDR_PULL_ALLOC(ndr, r->name_array);
16715                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16716                         } else {
16717                                 r->name_array = NULL;
16718                         }
16719                         ndr->flags = _flags_save_string;
16720                 }
16721         }
16722         if (ndr_flags & NDR_BUFFERS) {
16723                 {
16724                         uint32_t _flags_save_string = ndr->flags;
16725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16726                         if (r->name_array) {
16727                                 uint32_t _relative_save_offset;
16728                                 _relative_save_offset = ndr->offset;
16729                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16730                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16731                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16732                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16733                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16734                                 ndr->offset = _relative_save_offset;
16735                         }
16736                         ndr->flags = _flags_save_string;
16737                 }
16738         }
16739         return NDR_ERR_SUCCESS;
16740 }
16741
16742 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16743 {
16744         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16745         ndr->depth++;
16746         ndr_print_ptr(ndr, "name_array", r->name_array);
16747         ndr->depth++;
16748         if (r->name_array) {
16749                 ndr_print_string(ndr, "name_array", r->name_array);
16750         }
16751         ndr->depth--;
16752         ndr->depth--;
16753 }
16754
16755 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16756 {
16757         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16758 }
16759
16760 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16761 {
16762         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16763         if (ndr_flags & NDR_SCALARS) {
16764                 int level = ndr_push_get_switch_value(ndr, r);
16765                 switch (level) {
16766                         case 1: {
16767                                 NDR_CHECK(ndr_push_align(ndr, 4));
16768                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16769                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16770                         break; }
16771
16772                         default: {
16773                         break; }
16774
16775                 }
16776         }
16777         if (ndr_flags & NDR_BUFFERS) {
16778                 int level = ndr_push_get_switch_value(ndr, r);
16779                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16780                 switch (level) {
16781                         case 1:
16782                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16783                         break;
16784
16785                         default:
16786                         break;
16787
16788                 }
16789         }
16790         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16791         return NDR_ERR_SUCCESS;
16792 }
16793
16794 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16795 {
16796         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16797         int level;
16798         level = ndr_pull_get_switch_value(ndr, r);
16799         if (ndr_flags & NDR_SCALARS) {
16800                 switch (level) {
16801                         case 1: {
16802                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16803                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16804                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16805                         break; }
16806
16807                         default: {
16808                         break; }
16809
16810                 }
16811         }
16812         if (ndr_flags & NDR_BUFFERS) {
16813                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16814                 switch (level) {
16815                         case 1:
16816                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16817                         break;
16818
16819                         default:
16820                         break;
16821
16822                 }
16823         }
16824         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16825         return NDR_ERR_SUCCESS;
16826 }
16827
16828 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16829 {
16830         int level;
16831         level = ndr_print_get_switch_value(ndr, r);
16832         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16833         switch (level) {
16834                 case 1:
16835                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16836                 break;
16837
16838                 default:
16839                 break;
16840
16841         }
16842 }
16843
16844 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16845 {
16846         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16847         return NDR_ERR_SUCCESS;
16848 }
16849
16850 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16851 {
16852         uint32_t v;
16853         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16854         *r = v;
16855         return NDR_ERR_SUCCESS;
16856 }
16857
16858 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16859 {
16860         ndr_print_uint32(ndr, name, r);
16861         ndr->depth++;
16862         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16863         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16864         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16865         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16866         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16867         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16868         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16869         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16870         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16871         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16872         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16873         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16874         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16875         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16877         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16878         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16883         ndr->depth--;
16884 }
16885
16886 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16887 {
16888         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16889         return NDR_ERR_SUCCESS;
16890 }
16891
16892 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
16893 {
16894         uint16_t v;
16895         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16896         *r = v;
16897         return NDR_ERR_SUCCESS;
16898 }
16899
16900 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16901 {
16902         const char *val = NULL;
16903
16904         switch (r) {
16905                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16906                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16907                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16908                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16909                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16910                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16911                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16912                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16913                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16914                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
16915                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
16916                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
16917                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
16918                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
16919                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
16920                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
16921                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
16922                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
16923                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
16924                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
16925                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
16926                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
16927                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
16928                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
16929                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
16930                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
16931         }
16932         ndr_print_enum(ndr, name, "ENUM", val, r);
16933 }
16934
16935 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
16936 {
16937         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16938         return NDR_ERR_SUCCESS;
16939 }
16940
16941 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
16942 {
16943         uint16_t v;
16944         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16945         *r = v;
16946         return NDR_ERR_SUCCESS;
16947 }
16948
16949 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
16950 {
16951         const char *val = NULL;
16952
16953         switch (r) {
16954                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
16955                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
16956         }
16957         ndr_print_enum(ndr, name, "ENUM", val, r);
16958 }
16959
16960 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
16961 {
16962         uint32_t cntr_fields_1;
16963         if (ndr_flags & NDR_SCALARS) {
16964                 NDR_CHECK(ndr_push_align(ndr, 4));
16965                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
16966                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
16967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
16968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
16969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
16970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
16971         }
16972         if (ndr_flags & NDR_BUFFERS) {
16973                 if (r->fields) {
16974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
16975                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
16976                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
16977                         }
16978                 }
16979         }
16980         return NDR_ERR_SUCCESS;
16981 }
16982
16983 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
16984 {
16985         uint32_t _ptr_fields;
16986         uint32_t cntr_fields_1;
16987         TALLOC_CTX *_mem_save_fields_0;
16988         TALLOC_CTX *_mem_save_fields_1;
16989         if (ndr_flags & NDR_SCALARS) {
16990                 NDR_CHECK(ndr_pull_align(ndr, 4));
16991                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
16992                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
16993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
16994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
16995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
16996                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
16997                 if (_ptr_fields) {
16998                         NDR_PULL_ALLOC(ndr, r->fields);
16999                 } else {
17000                         r->fields = NULL;
17001                 }
17002         }
17003         if (ndr_flags & NDR_BUFFERS) {
17004                 if (r->fields) {
17005                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17006                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17008                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17009                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17010                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17011                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17012                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17013                         }
17014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17016                 }
17017                 if (r->fields) {
17018                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17019                 }
17020         }
17021         return NDR_ERR_SUCCESS;
17022 }
17023
17024 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17025 {
17026         uint32_t cntr_fields_1;
17027         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17028         ndr->depth++;
17029         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17030         ndr_print_uint16(ndr, "u1", r->u1);
17031         ndr_print_uint32(ndr, "u2", r->u2);
17032         ndr_print_uint32(ndr, "u3", r->u3);
17033         ndr_print_uint32(ndr, "count", r->count);
17034         ndr_print_ptr(ndr, "fields", r->fields);
17035         ndr->depth++;
17036         if (r->fields) {
17037                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17038                 ndr->depth++;
17039                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17040                         char *idx_1=NULL;
17041                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17042                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
17043                                 free(idx_1);
17044                         }
17045                 }
17046                 ndr->depth--;
17047         }
17048         ndr->depth--;
17049         ndr->depth--;
17050 }
17051
17052 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17053 {
17054         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17055         return NDR_ERR_SUCCESS;
17056 }
17057
17058 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17059 {
17060         uint32_t v;
17061         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17062         *r = v;
17063         return NDR_ERR_SUCCESS;
17064 }
17065
17066 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17067 {
17068         ndr_print_uint32(ndr, name, r);
17069         ndr->depth++;
17070         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17071         ndr->depth--;
17072 }
17073
17074 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17075 {
17076         uint32_t cntr_types_1;
17077         if (ndr_flags & NDR_SCALARS) {
17078                 NDR_CHECK(ndr_push_align(ndr, 4));
17079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17080                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17082                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17083         }
17084         if (ndr_flags & NDR_BUFFERS) {
17085                 if (r->types) {
17086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17087                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17088                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17089                         }
17090                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17091                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17092                         }
17093                 }
17094         }
17095         return NDR_ERR_SUCCESS;
17096 }
17097
17098 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17099 {
17100         uint32_t _ptr_types;
17101         uint32_t cntr_types_1;
17102         TALLOC_CTX *_mem_save_types_0;
17103         TALLOC_CTX *_mem_save_types_1;
17104         if (ndr_flags & NDR_SCALARS) {
17105                 NDR_CHECK(ndr_pull_align(ndr, 4));
17106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17107                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17110                 if (_ptr_types) {
17111                         NDR_PULL_ALLOC(ndr, r->types);
17112                 } else {
17113                         r->types = NULL;
17114                 }
17115         }
17116         if (ndr_flags & NDR_BUFFERS) {
17117                 if (r->types) {
17118                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17119                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17121                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17122                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17123                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17124                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17125                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17126                         }
17127                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17128                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17129                         }
17130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17131                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17132                 }
17133                 if (r->types) {
17134                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17135                 }
17136         }
17137         return NDR_ERR_SUCCESS;
17138 }
17139
17140 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17141 {
17142         uint32_t cntr_types_1;
17143         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17144         ndr->depth++;
17145         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17146         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17147         ndr_print_uint32(ndr, "count", r->count);
17148         ndr_print_ptr(ndr, "types", r->types);
17149         ndr->depth++;
17150         if (r->types) {
17151                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17152                 ndr->depth++;
17153                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17154                         char *idx_1=NULL;
17155                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17156                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17157                                 free(idx_1);
17158                         }
17159                 }
17160                 ndr->depth--;
17161         }
17162         ndr->depth--;
17163         ndr->depth--;
17164 }
17165
17166 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17167 {
17168         if (ndr_flags & NDR_SCALARS) {
17169                 NDR_CHECK(ndr_push_align(ndr, 4));
17170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17172         }
17173         if (ndr_flags & NDR_BUFFERS) {
17174                 if (r->string) {
17175                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17176                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17177                 }
17178         }
17179         return NDR_ERR_SUCCESS;
17180 }
17181
17182 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17183 {
17184         uint32_t _ptr_string;
17185         TALLOC_CTX *_mem_save_string_0;
17186         if (ndr_flags & NDR_SCALARS) {
17187                 NDR_CHECK(ndr_pull_align(ndr, 4));
17188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17189                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17190                 if (_ptr_string) {
17191                         NDR_PULL_ALLOC(ndr, r->string);
17192                 } else {
17193                         r->string = NULL;
17194                 }
17195         }
17196         if (ndr_flags & NDR_BUFFERS) {
17197                 if (r->string) {
17198                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17199                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17201                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17203                 }
17204                 if (r->string) {
17205                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17206                 }
17207         }
17208         return NDR_ERR_SUCCESS;
17209 }
17210
17211 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17212 {
17213         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17214         ndr->depth++;
17215         ndr_print_uint32(ndr, "size", r->size);
17216         ndr_print_ptr(ndr, "string", r->string);
17217         ndr->depth++;
17218         if (r->string) {
17219                 ndr_print_string(ndr, "string", r->string);
17220         }
17221         ndr->depth--;
17222         ndr->depth--;
17223 }
17224
17225 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17226 {
17227         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17228         return NDR_ERR_SUCCESS;
17229 }
17230
17231 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17232 {
17233         uint32_t v;
17234         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17235         *r = v;
17236         return NDR_ERR_SUCCESS;
17237 }
17238
17239 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17240 {
17241         const char *val = NULL;
17242
17243         switch (r) {
17244                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17245                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17246                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17247                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17248                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17249         }
17250         ndr_print_enum(ndr, name, "ENUM", val, r);
17251 }
17252
17253 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17254 {
17255         if (ndr_flags & NDR_SCALARS) {
17256                 int level = ndr_push_get_switch_value(ndr, r);
17257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17258                 switch (level) {
17259                         case 1: {
17260                                 uint32_t cntr_integer_0;
17261                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17262                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17263                                 }
17264                         break; }
17265
17266                         case 2: {
17267                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17268                         break; }
17269
17270                         case 3: {
17271                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17272                         break; }
17273
17274                         case 4: {
17275                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17276                         break; }
17277
17278                         case 5: {
17279                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17280                         break; }
17281
17282                         default:
17283                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17284                 }
17285         }
17286         if (ndr_flags & NDR_BUFFERS) {
17287                 int level = ndr_push_get_switch_value(ndr, r);
17288                 switch (level) {
17289                         case 1:
17290                         break;
17291
17292                         case 2:
17293                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17294                         break;
17295
17296                         case 3:
17297                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17298                         break;
17299
17300                         case 4:
17301                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17302                         break;
17303
17304                         case 5:
17305                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17306                         break;
17307
17308                         default:
17309                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17310                 }
17311         }
17312         return NDR_ERR_SUCCESS;
17313 }
17314
17315 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17316 {
17317         int level;
17318         uint32_t _level;
17319         level = ndr_pull_get_switch_value(ndr, r);
17320         if (ndr_flags & NDR_SCALARS) {
17321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17322                 if (_level != level) {
17323                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17324                 }
17325                 switch (level) {
17326                         case 1: {
17327                                 uint32_t cntr_integer_0;
17328                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17329                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17330                                 }
17331                         break; }
17332
17333                         case 2: {
17334                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17335                         break; }
17336
17337                         case 3: {
17338                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17339                         break; }
17340
17341                         case 4: {
17342                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17343                         break; }
17344
17345                         case 5: {
17346                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17347                         break; }
17348
17349                         default:
17350                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17351                 }
17352         }
17353         if (ndr_flags & NDR_BUFFERS) {
17354                 switch (level) {
17355                         case 1:
17356                         break;
17357
17358                         case 2:
17359                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17360                         break;
17361
17362                         case 3:
17363                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17364                         break;
17365
17366                         case 4:
17367                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17368                         break;
17369
17370                         case 5:
17371                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17372                         break;
17373
17374                         default:
17375                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17376                 }
17377         }
17378         return NDR_ERR_SUCCESS;
17379 }
17380
17381 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17382 {
17383         int level;
17384         uint32_t cntr_integer_0;
17385         level = ndr_print_get_switch_value(ndr, r);
17386         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17387         switch (level) {
17388                 case 1:
17389                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17390                         ndr->depth++;
17391                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17392                                 char *idx_0=NULL;
17393                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17394                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17395                                         free(idx_0);
17396                                 }
17397                         }
17398                         ndr->depth--;
17399                 break;
17400
17401                 case 2:
17402                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17403                 break;
17404
17405                 case 3:
17406                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17407                 break;
17408
17409                 case 4:
17410                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17411                 break;
17412
17413                 case 5:
17414                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17415                 break;
17416
17417                 default:
17418                         ndr_print_bad_level(ndr, name, level);
17419         }
17420 }
17421
17422 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17423 {
17424         if (ndr_flags & NDR_SCALARS) {
17425                 NDR_CHECK(ndr_push_align(ndr, 4));
17426                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17427                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17428                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17430                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17431                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17432         }
17433         if (ndr_flags & NDR_BUFFERS) {
17434                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17435         }
17436         return NDR_ERR_SUCCESS;
17437 }
17438
17439 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17440 {
17441         if (ndr_flags & NDR_SCALARS) {
17442                 NDR_CHECK(ndr_pull_align(ndr, 4));
17443                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17444                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17445                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17447                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17448                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17449         }
17450         if (ndr_flags & NDR_BUFFERS) {
17451                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17452         }
17453         return NDR_ERR_SUCCESS;
17454 }
17455
17456 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17457 {
17458         ndr_print_struct(ndr, name, "spoolss_Notify");
17459         ndr->depth++;
17460         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17461         ndr_print_spoolss_Field(ndr, "field", r->field);
17462         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17463         ndr_print_uint32(ndr, "job_id", r->job_id);
17464         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17465         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17466         ndr->depth--;
17467 }
17468
17469 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17470 {
17471         uint32_t cntr_notifies_0;
17472         if (ndr_flags & NDR_SCALARS) {
17473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17474                 NDR_CHECK(ndr_push_align(ndr, 4));
17475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17478                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17479                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17480                 }
17481         }
17482         if (ndr_flags & NDR_BUFFERS) {
17483                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17484                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17485                 }
17486         }
17487         return NDR_ERR_SUCCESS;
17488 }
17489
17490 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17491 {
17492         uint32_t cntr_notifies_0;
17493         TALLOC_CTX *_mem_save_notifies_0;
17494         if (ndr_flags & NDR_SCALARS) {
17495                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17496                 NDR_CHECK(ndr_pull_align(ndr, 4));
17497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17500                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17501                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17502                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17503                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17504                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17505                 }
17506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17507                 if (r->notifies) {
17508                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17509                 }
17510         }
17511         if (ndr_flags & NDR_BUFFERS) {
17512                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17513                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17514                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17515                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17516                 }
17517                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17518         }
17519         return NDR_ERR_SUCCESS;
17520 }
17521
17522 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17523 {
17524         uint32_t cntr_notifies_0;
17525         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17526         ndr->depth++;
17527         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17528         ndr_print_uint32(ndr, "flags", r->flags);
17529         ndr_print_uint32(ndr, "count", r->count);
17530         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17531         ndr->depth++;
17532         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17533                 char *idx_0=NULL;
17534                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17535                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17536                         free(idx_0);
17537                 }
17538         }
17539         ndr->depth--;
17540         ndr->depth--;
17541 }
17542
17543 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17544 {
17545         if (ndr_flags & NDR_SCALARS) {
17546                 int level = ndr_push_get_switch_value(ndr, r);
17547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17548                 switch (level) {
17549                         case 0: {
17550                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17551                         break; }
17552
17553                         default:
17554                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17555                 }
17556         }
17557         if (ndr_flags & NDR_BUFFERS) {
17558                 int level = ndr_push_get_switch_value(ndr, r);
17559                 switch (level) {
17560                         case 0:
17561                                 if (r->info0) {
17562                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17563                                 }
17564                         break;
17565
17566                         default:
17567                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17568                 }
17569         }
17570         return NDR_ERR_SUCCESS;
17571 }
17572
17573 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17574 {
17575         int level;
17576         uint32_t _level;
17577         TALLOC_CTX *_mem_save_info0_0;
17578         level = ndr_pull_get_switch_value(ndr, r);
17579         if (ndr_flags & NDR_SCALARS) {
17580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17581                 if (_level != level) {
17582                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17583                 }
17584                 switch (level) {
17585                         case 0: {
17586                                 uint32_t _ptr_info0;
17587                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17588                                 if (_ptr_info0) {
17589                                         NDR_PULL_ALLOC(ndr, r->info0);
17590                                 } else {
17591                                         r->info0 = NULL;
17592                                 }
17593                         break; }
17594
17595                         default:
17596                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17597                 }
17598         }
17599         if (ndr_flags & NDR_BUFFERS) {
17600                 switch (level) {
17601                         case 0:
17602                                 if (r->info0) {
17603                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17604                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17605                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17606                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17607                                 }
17608                         break;
17609
17610                         default:
17611                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17612                 }
17613         }
17614         return NDR_ERR_SUCCESS;
17615 }
17616
17617 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17618 {
17619         int level;
17620         level = ndr_print_get_switch_value(ndr, r);
17621         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17622         switch (level) {
17623                 case 0:
17624                         ndr_print_ptr(ndr, "info0", r->info0);
17625                         ndr->depth++;
17626                         if (r->info0) {
17627                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17628                         }
17629                         ndr->depth--;
17630                 break;
17631
17632                 default:
17633                         ndr_print_bad_level(ndr, name, level);
17634         }
17635 }
17636
17637 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17638 {
17639         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17640         return NDR_ERR_SUCCESS;
17641 }
17642
17643 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17644 {
17645         uint32_t v;
17646         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17647         *r = v;
17648         return NDR_ERR_SUCCESS;
17649 }
17650
17651 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17652 {
17653         ndr_print_uint32(ndr, name, r);
17654         ndr->depth++;
17655         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17656         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17657         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17658         ndr->depth--;
17659 }
17660
17661 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17662 {
17663         if (ndr_flags & NDR_SCALARS) {
17664                 NDR_CHECK(ndr_push_align(ndr, 4));
17665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17666                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17669                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17670                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17671                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17672         }
17673         if (ndr_flags & NDR_BUFFERS) {
17674                 if (r->client) {
17675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17677                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17678                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17679                 }
17680                 if (r->user) {
17681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17684                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17685                 }
17686         }
17687         return NDR_ERR_SUCCESS;
17688 }
17689
17690 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17691 {
17692         uint32_t _ptr_client;
17693         TALLOC_CTX *_mem_save_client_0;
17694         uint32_t _ptr_user;
17695         TALLOC_CTX *_mem_save_user_0;
17696         if (ndr_flags & NDR_SCALARS) {
17697                 NDR_CHECK(ndr_pull_align(ndr, 4));
17698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17700                 if (_ptr_client) {
17701                         NDR_PULL_ALLOC(ndr, r->client);
17702                 } else {
17703                         r->client = NULL;
17704                 }
17705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17706                 if (_ptr_user) {
17707                         NDR_PULL_ALLOC(ndr, r->user);
17708                 } else {
17709                         r->user = NULL;
17710                 }
17711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17712                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17713                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17714                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17715         }
17716         if (ndr_flags & NDR_BUFFERS) {
17717                 if (r->client) {
17718                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17719                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17720                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17721                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17722                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17723                                 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));
17724                         }
17725                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17726                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17728                 }
17729                 if (r->user) {
17730                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17731                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17732                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17733                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17734                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17735                                 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));
17736                         }
17737                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17738                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17740                 }
17741         }
17742         return NDR_ERR_SUCCESS;
17743 }
17744
17745 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17746 {
17747         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17748         ndr->depth++;
17749         ndr_print_uint32(ndr, "size", r->size);
17750         ndr_print_ptr(ndr, "client", r->client);
17751         ndr->depth++;
17752         if (r->client) {
17753                 ndr_print_string(ndr, "client", r->client);
17754         }
17755         ndr->depth--;
17756         ndr_print_ptr(ndr, "user", r->user);
17757         ndr->depth++;
17758         if (r->user) {
17759                 ndr_print_string(ndr, "user", r->user);
17760         }
17761         ndr->depth--;
17762         ndr_print_uint32(ndr, "build", r->build);
17763         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17764         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17765         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17766         ndr->depth--;
17767 }
17768
17769 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17770 {
17771         if (ndr_flags & NDR_SCALARS) {
17772                 NDR_CHECK(ndr_push_align(ndr, 4));
17773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17774         }
17775         if (ndr_flags & NDR_BUFFERS) {
17776         }
17777         return NDR_ERR_SUCCESS;
17778 }
17779
17780 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17781 {
17782         if (ndr_flags & NDR_SCALARS) {
17783                 NDR_CHECK(ndr_pull_align(ndr, 4));
17784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17785         }
17786         if (ndr_flags & NDR_BUFFERS) {
17787         }
17788         return NDR_ERR_SUCCESS;
17789 }
17790
17791 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17792 {
17793         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17794         ndr->depth++;
17795         ndr_print_uint32(ndr, "not_used", r->not_used);
17796         ndr->depth--;
17797 }
17798
17799 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17800 {
17801         if (ndr_flags & NDR_SCALARS) {
17802                 NDR_CHECK(ndr_push_align(ndr, 4));
17803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17809                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17810                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17811                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17812                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17813         }
17814         if (ndr_flags & NDR_BUFFERS) {
17815                 if (r->client) {
17816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17819                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17820                 }
17821                 if (r->user) {
17822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17825                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17826                 }
17827         }
17828         return NDR_ERR_SUCCESS;
17829 }
17830
17831 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17832 {
17833         uint32_t _ptr_client;
17834         TALLOC_CTX *_mem_save_client_0;
17835         uint32_t _ptr_user;
17836         TALLOC_CTX *_mem_save_user_0;
17837         if (ndr_flags & NDR_SCALARS) {
17838                 NDR_CHECK(ndr_pull_align(ndr, 4));
17839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17843                 if (_ptr_client) {
17844                         NDR_PULL_ALLOC(ndr, r->client);
17845                 } else {
17846                         r->client = NULL;
17847                 }
17848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17849                 if (_ptr_user) {
17850                         NDR_PULL_ALLOC(ndr, r->user);
17851                 } else {
17852                         r->user = NULL;
17853                 }
17854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17855                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17856                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17857                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17858                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17859         }
17860         if (ndr_flags & NDR_BUFFERS) {
17861                 if (r->client) {
17862                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17863                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17864                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17865                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17866                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17867                                 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));
17868                         }
17869                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17870                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17872                 }
17873                 if (r->user) {
17874                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17875                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17876                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17877                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17878                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17879                                 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));
17880                         }
17881                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17882                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17884                 }
17885         }
17886         return NDR_ERR_SUCCESS;
17887 }
17888
17889 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17890 {
17891         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17892         ndr->depth++;
17893         ndr_print_uint32(ndr, "size", r->size);
17894         ndr_print_uint32(ndr, "flags", r->flags);
17895         ndr_print_uint32(ndr, "size2", r->size2);
17896         ndr_print_ptr(ndr, "client", r->client);
17897         ndr->depth++;
17898         if (r->client) {
17899                 ndr_print_string(ndr, "client", r->client);
17900         }
17901         ndr->depth--;
17902         ndr_print_ptr(ndr, "user", r->user);
17903         ndr->depth++;
17904         if (r->user) {
17905                 ndr_print_string(ndr, "user", r->user);
17906         }
17907         ndr->depth--;
17908         ndr_print_uint32(ndr, "build", r->build);
17909         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17910         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17911         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17912         ndr_print_udlong(ndr, "reserved", r->reserved);
17913         ndr->depth--;
17914 }
17915
17916 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
17917 {
17918         if (ndr_flags & NDR_SCALARS) {
17919                 int level = ndr_push_get_switch_value(ndr, r);
17920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17921                 switch (level) {
17922                         case 1: {
17923                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
17924                         break; }
17925
17926                         case 2: {
17927                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
17928                         break; }
17929
17930                         case 3: {
17931                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
17932                         break; }
17933
17934                         default:
17935                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17936                 }
17937         }
17938         if (ndr_flags & NDR_BUFFERS) {
17939                 int level = ndr_push_get_switch_value(ndr, r);
17940                 switch (level) {
17941                         case 1:
17942                                 if (r->level1) {
17943                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
17944                                 }
17945                         break;
17946
17947                         case 2:
17948                                 if (r->level2) {
17949                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
17950                                 }
17951                         break;
17952
17953                         case 3:
17954                                 if (r->level3) {
17955                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
17956                                 }
17957                         break;
17958
17959                         default:
17960                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17961                 }
17962         }
17963         return NDR_ERR_SUCCESS;
17964 }
17965
17966 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
17967 {
17968         int level;
17969         uint32_t _level;
17970         TALLOC_CTX *_mem_save_level1_0;
17971         TALLOC_CTX *_mem_save_level2_0;
17972         TALLOC_CTX *_mem_save_level3_0;
17973         level = ndr_pull_get_switch_value(ndr, r);
17974         if (ndr_flags & NDR_SCALARS) {
17975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17976                 if (_level != level) {
17977                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17978                 }
17979                 switch (level) {
17980                         case 1: {
17981                                 uint32_t _ptr_level1;
17982                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
17983                                 if (_ptr_level1) {
17984                                         NDR_PULL_ALLOC(ndr, r->level1);
17985                                 } else {
17986                                         r->level1 = NULL;
17987                                 }
17988                         break; }
17989
17990                         case 2: {
17991                                 uint32_t _ptr_level2;
17992                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
17993                                 if (_ptr_level2) {
17994                                         NDR_PULL_ALLOC(ndr, r->level2);
17995                                 } else {
17996                                         r->level2 = NULL;
17997                                 }
17998                         break; }
17999
18000                         case 3: {
18001                                 uint32_t _ptr_level3;
18002                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18003                                 if (_ptr_level3) {
18004                                         NDR_PULL_ALLOC(ndr, r->level3);
18005                                 } else {
18006                                         r->level3 = NULL;
18007                                 }
18008                         break; }
18009
18010                         default:
18011                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18012                 }
18013         }
18014         if (ndr_flags & NDR_BUFFERS) {
18015                 switch (level) {
18016                         case 1:
18017                                 if (r->level1) {
18018                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18019                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18020                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18021                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18022                                 }
18023                         break;
18024
18025                         case 2:
18026                                 if (r->level2) {
18027                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18028                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18029                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18030                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18031                                 }
18032                         break;
18033
18034                         case 3:
18035                                 if (r->level3) {
18036                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18037                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18038                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18039                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18040                                 }
18041                         break;
18042
18043                         default:
18044                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18045                 }
18046         }
18047         return NDR_ERR_SUCCESS;
18048 }
18049
18050 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18051 {
18052         int level;
18053         level = ndr_print_get_switch_value(ndr, r);
18054         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18055         switch (level) {
18056                 case 1:
18057                         ndr_print_ptr(ndr, "level1", r->level1);
18058                         ndr->depth++;
18059                         if (r->level1) {
18060                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18061                         }
18062                         ndr->depth--;
18063                 break;
18064
18065                 case 2:
18066                         ndr_print_ptr(ndr, "level2", r->level2);
18067                         ndr->depth++;
18068                         if (r->level2) {
18069                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18070                         }
18071                         ndr->depth--;
18072                 break;
18073
18074                 case 3:
18075                         ndr_print_ptr(ndr, "level3", r->level3);
18076                         ndr->depth++;
18077                         if (r->level3) {
18078                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18079                         }
18080                         ndr->depth--;
18081                 break;
18082
18083                 default:
18084                         ndr_print_bad_level(ndr, name, level);
18085         }
18086 }
18087
18088 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18089 {
18090         if (ndr_flags & NDR_SCALARS) {
18091                 NDR_CHECK(ndr_push_align(ndr, 4));
18092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18093                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18094                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18095         }
18096         if (ndr_flags & NDR_BUFFERS) {
18097                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18098         }
18099         return NDR_ERR_SUCCESS;
18100 }
18101
18102 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18103 {
18104         if (ndr_flags & NDR_SCALARS) {
18105                 NDR_CHECK(ndr_pull_align(ndr, 4));
18106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18107                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18108                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18109         }
18110         if (ndr_flags & NDR_BUFFERS) {
18111                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18112         }
18113         return NDR_ERR_SUCCESS;
18114 }
18115
18116 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18117 {
18118         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18119         ndr->depth++;
18120         ndr_print_uint32(ndr, "level", r->level);
18121         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18122         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18123         ndr->depth--;
18124 }
18125
18126 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18127 {
18128         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18129         return NDR_ERR_SUCCESS;
18130 }
18131
18132 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18133 {
18134         uint32_t v;
18135         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18136         *r = v;
18137         return NDR_ERR_SUCCESS;
18138 }
18139
18140 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18141 {
18142         ndr_print_uint32(ndr, name, r);
18143         ndr->depth++;
18144         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18145         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18146         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18147         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18148         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18149         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18150         ndr->depth--;
18151 }
18152
18153 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18154 {
18155         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18156         return NDR_ERR_SUCCESS;
18157 }
18158
18159 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18160 {
18161         uint32_t v;
18162         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18163         *r = v;
18164         return NDR_ERR_SUCCESS;
18165 }
18166
18167 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18168 {
18169         ndr_print_uint32(ndr, name, r);
18170         ndr->depth++;
18171         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18172         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18173         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18174         ndr->depth--;
18175 }
18176
18177 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18178 {
18179         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18180         return NDR_ERR_SUCCESS;
18181 }
18182
18183 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18184 {
18185         uint32_t v;
18186         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18187         *r = v;
18188         return NDR_ERR_SUCCESS;
18189 }
18190
18191 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18192 {
18193         const char *val = NULL;
18194
18195         switch (r) {
18196                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18197                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18198         }
18199         ndr_print_enum(ndr, name, "ENUM", val, r);
18200 }
18201
18202 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18203 {
18204         if (ndr_flags & NDR_SCALARS) {
18205                 NDR_CHECK(ndr_push_align(ndr, 4));
18206                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18208                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18211                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18212                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18214                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18215                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18216                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18217                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18221         }
18222         if (ndr_flags & NDR_BUFFERS) {
18223         }
18224         return NDR_ERR_SUCCESS;
18225 }
18226
18227 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18228 {
18229         if (ndr_flags & NDR_SCALARS) {
18230                 NDR_CHECK(ndr_pull_align(ndr, 4));
18231                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18233                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18236                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18237                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18239                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18240                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18241                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18242                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18246         }
18247         if (ndr_flags & NDR_BUFFERS) {
18248         }
18249         return NDR_ERR_SUCCESS;
18250 }
18251
18252 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18253 {
18254         ndr_print_struct(ndr, name, "spoolss_PortData1");
18255         ndr->depth++;
18256         ndr_print_string(ndr, "portname", r->portname);
18257         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18258         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18259         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18260         ndr_print_uint32(ndr, "reserved", r->reserved);
18261         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18262         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18263         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18264         ndr_print_string(ndr, "queue", r->queue);
18265         ndr_print_string(ndr, "ip_address", r->ip_address);
18266         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18267         ndr_print_string(ndr, "device_type", r->device_type);
18268         ndr_print_uint32(ndr, "port_number", r->port_number);
18269         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18270         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18271         ndr->depth--;
18272 }
18273
18274 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18275 {
18276         if (ndr_flags & NDR_SCALARS) {
18277                 NDR_CHECK(ndr_push_align(ndr, 4));
18278                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18280                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18283                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18284                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18286                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18287                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18292         }
18293         if (ndr_flags & NDR_BUFFERS) {
18294         }
18295         return NDR_ERR_SUCCESS;
18296 }
18297
18298 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18299 {
18300         if (ndr_flags & NDR_SCALARS) {
18301                 NDR_CHECK(ndr_pull_align(ndr, 4));
18302                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18304                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18307                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18308                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18310                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18311                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18316         }
18317         if (ndr_flags & NDR_BUFFERS) {
18318         }
18319         return NDR_ERR_SUCCESS;
18320 }
18321
18322 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18323 {
18324         ndr_print_struct(ndr, name, "spoolss_PortData2");
18325         ndr->depth++;
18326         ndr_print_string(ndr, "portname", r->portname);
18327         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18328         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18329         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18330         ndr_print_uint32(ndr, "reserved", r->reserved);
18331         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18332         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18333         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18334         ndr_print_string(ndr, "queue", r->queue);
18335         ndr_print_string(ndr, "device_type", r->device_type);
18336         ndr_print_uint32(ndr, "port_number", r->port_number);
18337         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18338         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18339         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18340         ndr->depth--;
18341 }
18342
18343 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18344 {
18345         if (ndr_flags & NDR_SCALARS) {
18346                 NDR_CHECK(ndr_push_align(ndr, 4));
18347                 {
18348                         uint32_t _flags_save_string = ndr->flags;
18349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18350                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18351                         ndr->flags = _flags_save_string;
18352                 }
18353         }
18354         if (ndr_flags & NDR_BUFFERS) {
18355         }
18356         return NDR_ERR_SUCCESS;
18357 }
18358
18359 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18360 {
18361         if (ndr_flags & NDR_SCALARS) {
18362                 NDR_CHECK(ndr_pull_align(ndr, 4));
18363                 {
18364                         uint32_t _flags_save_string = ndr->flags;
18365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18366                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18367                         ndr->flags = _flags_save_string;
18368                 }
18369         }
18370         if (ndr_flags & NDR_BUFFERS) {
18371         }
18372         return NDR_ERR_SUCCESS;
18373 }
18374
18375 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18376 {
18377         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18378         ndr->depth++;
18379         ndr_print_string(ndr, "dll_name", r->dll_name);
18380         ndr->depth--;
18381 }
18382
18383 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18384 {
18385         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18386         return NDR_ERR_SUCCESS;
18387 }
18388
18389 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18390 {
18391         uint32_t v;
18392         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18393         *r = v;
18394         return NDR_ERR_SUCCESS;
18395 }
18396
18397 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18398 {
18399         ndr_print_uint32(ndr, name, r);
18400         ndr->depth++;
18401         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18402         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18403         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18404         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18405         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18406         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18407         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18408         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18409         ndr->depth--;
18410 }
18411
18412 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18413 {
18414         if (flags & NDR_IN) {
18415                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18417                 if (r->in.server) {
18418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18422                 }
18423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18425                 if (r->in.buffer) {
18426                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18427                 }
18428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18429         }
18430         if (flags & NDR_OUT) {
18431                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18432                 if (r->out.info) {
18433                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18434                 }
18435                 if (r->out.needed == NULL) {
18436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18437                 }
18438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18439                 if (r->out.count == NULL) {
18440                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18441                 }
18442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18443                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18444         }
18445         return NDR_ERR_SUCCESS;
18446 }
18447
18448 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18449 {
18450         uint32_t _ptr_server;
18451         uint32_t _ptr_buffer;
18452         uint32_t _ptr_info;
18453         TALLOC_CTX *_mem_save_server_0;
18454         TALLOC_CTX *_mem_save_buffer_0;
18455         TALLOC_CTX *_mem_save_info_0;
18456         TALLOC_CTX *_mem_save_needed_0;
18457         TALLOC_CTX *_mem_save_count_0;
18458         if (flags & NDR_IN) {
18459                 ZERO_STRUCT(r->out);
18460
18461                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18463                 if (_ptr_server) {
18464                         NDR_PULL_ALLOC(ndr, r->in.server);
18465                 } else {
18466                         r->in.server = NULL;
18467                 }
18468                 if (r->in.server) {
18469                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18470                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18471                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18472                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18473                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18474                                 return 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));
18475                         }
18476                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18477                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18479                 }
18480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18481                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18482                 if (_ptr_buffer) {
18483                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18484                 } else {
18485                         r->in.buffer = NULL;
18486                 }
18487                 if (r->in.buffer) {
18488                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18489                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18490                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18491                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18492                 }
18493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18494                 NDR_PULL_ALLOC(ndr, r->out.needed);
18495                 ZERO_STRUCTP(r->out.needed);
18496                 NDR_PULL_ALLOC(ndr, r->out.count);
18497                 ZERO_STRUCTP(r->out.count);
18498         }
18499         if (flags & NDR_OUT) {
18500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18501                 if (_ptr_info) {
18502                         NDR_PULL_ALLOC(ndr, r->out.info);
18503                 } else {
18504                         r->out.info = NULL;
18505                 }
18506                 if (r->out.info) {
18507                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18508                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18509                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18511                 }
18512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18513                         NDR_PULL_ALLOC(ndr, r->out.needed);
18514                 }
18515                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18516                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18520                         NDR_PULL_ALLOC(ndr, r->out.count);
18521                 }
18522                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18523                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18526                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18527         }
18528         return NDR_ERR_SUCCESS;
18529 }
18530
18531 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18532 {
18533         uint32_t cntr_info_0;
18534         if (flags & NDR_IN) {
18535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18537         }
18538         if (flags & NDR_OUT) {
18539                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18540                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18541                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18542                 }
18543                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18544                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18545                 }
18546         }
18547         return NDR_ERR_SUCCESS;
18548 }
18549
18550 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18551 {
18552         uint32_t cntr_info_0;
18553         TALLOC_CTX *_mem_save_info_0;
18554         if (flags & NDR_IN) {
18555                 ZERO_STRUCT(r->out);
18556
18557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18559         }
18560         if (flags & NDR_OUT) {
18561                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18562                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18563                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18564                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18565                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18566                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18567                 }
18568                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18569                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18570                 }
18571                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18572         }
18573         return NDR_ERR_SUCCESS;
18574 }
18575
18576 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18577 {
18578         uint32_t cntr_info_2;
18579         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18580         ndr->depth++;
18581         if (flags & NDR_SET_VALUES) {
18582                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18583         }
18584         if (flags & NDR_IN) {
18585                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18586                 ndr->depth++;
18587                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18588                 ndr_print_ptr(ndr, "server", r->in.server);
18589                 ndr->depth++;
18590                 if (r->in.server) {
18591                         ndr_print_string(ndr, "server", r->in.server);
18592                 }
18593                 ndr->depth--;
18594                 ndr_print_uint32(ndr, "level", r->in.level);
18595                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18596                 ndr->depth++;
18597                 if (r->in.buffer) {
18598                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18599                 }
18600                 ndr->depth--;
18601                 ndr_print_uint32(ndr, "offered", r->in.offered);
18602                 ndr->depth--;
18603         }
18604         if (flags & NDR_OUT) {
18605                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18606                 ndr->depth++;
18607                 ndr_print_ptr(ndr, "count", r->out.count);
18608                 ndr->depth++;
18609                 ndr_print_uint32(ndr, "count", *r->out.count);
18610                 ndr->depth--;
18611                 ndr_print_ptr(ndr, "info", r->out.info);
18612                 ndr->depth++;
18613                 ndr_print_ptr(ndr, "info", *r->out.info);
18614                 ndr->depth++;
18615                 if (*r->out.info) {
18616                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18617                         ndr->depth++;
18618                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18619                                 char *idx_2=NULL;
18620                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18621                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18622                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18623                                         free(idx_2);
18624                                 }
18625                         }
18626                         ndr->depth--;
18627                 }
18628                 ndr->depth--;
18629                 ndr->depth--;
18630                 ndr_print_ptr(ndr, "needed", r->out.needed);
18631                 ndr->depth++;
18632                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18633                 ndr->depth--;
18634                 ndr_print_WERROR(ndr, "result", r->out.result);
18635                 ndr->depth--;
18636         }
18637         ndr->depth--;
18638 }
18639
18640 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18641 {
18642         if (flags & NDR_IN) {
18643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18644                 if (r->in.printername) {
18645                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18646                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18647                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18648                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18649                 }
18650                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18651                 if (r->in.datatype) {
18652                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18653                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18654                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18656                 }
18657                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18658                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18659         }
18660         if (flags & NDR_OUT) {
18661                 if (r->out.handle == NULL) {
18662                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18663                 }
18664                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18665                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18666         }
18667         return NDR_ERR_SUCCESS;
18668 }
18669
18670 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18671 {
18672         uint32_t _ptr_printername;
18673         uint32_t _ptr_datatype;
18674         TALLOC_CTX *_mem_save_printername_0;
18675         TALLOC_CTX *_mem_save_datatype_0;
18676         TALLOC_CTX *_mem_save_handle_0;
18677         if (flags & NDR_IN) {
18678                 ZERO_STRUCT(r->out);
18679
18680                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18681                 if (_ptr_printername) {
18682                         NDR_PULL_ALLOC(ndr, r->in.printername);
18683                 } else {
18684                         r->in.printername = NULL;
18685                 }
18686                 if (r->in.printername) {
18687                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18688                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18691                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18692                                 return 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));
18693                         }
18694                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18695                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18697                 }
18698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18699                 if (_ptr_datatype) {
18700                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18701                 } else {
18702                         r->in.datatype = NULL;
18703                 }
18704                 if (r->in.datatype) {
18705                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18706                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18707                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18708                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18709                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18710                                 return 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));
18711                         }
18712                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18713                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18714                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18715                 }
18716                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18717                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18718                 NDR_PULL_ALLOC(ndr, r->out.handle);
18719                 ZERO_STRUCTP(r->out.handle);
18720         }
18721         if (flags & NDR_OUT) {
18722                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18723                         NDR_PULL_ALLOC(ndr, r->out.handle);
18724                 }
18725                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18726                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18727                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18728                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18729                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18730         }
18731         return NDR_ERR_SUCCESS;
18732 }
18733
18734 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18735 {
18736         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18737         ndr->depth++;
18738         if (flags & NDR_SET_VALUES) {
18739                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18740         }
18741         if (flags & NDR_IN) {
18742                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18743                 ndr->depth++;
18744                 ndr_print_ptr(ndr, "printername", r->in.printername);
18745                 ndr->depth++;
18746                 if (r->in.printername) {
18747                         ndr_print_string(ndr, "printername", r->in.printername);
18748                 }
18749                 ndr->depth--;
18750                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18751                 ndr->depth++;
18752                 if (r->in.datatype) {
18753                         ndr_print_string(ndr, "datatype", r->in.datatype);
18754                 }
18755                 ndr->depth--;
18756                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18757                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18758                 ndr->depth--;
18759         }
18760         if (flags & NDR_OUT) {
18761                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18762                 ndr->depth++;
18763                 ndr_print_ptr(ndr, "handle", r->out.handle);
18764                 ndr->depth++;
18765                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18766                 ndr->depth--;
18767                 ndr_print_WERROR(ndr, "result", r->out.result);
18768                 ndr->depth--;
18769         }
18770         ndr->depth--;
18771 }
18772
18773 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18774 {
18775         if (flags & NDR_IN) {
18776                 if (r->in.handle == NULL) {
18777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18778                 }
18779                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
18782                 if (r->in.ctr) {
18783                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18784                 }
18785                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
18786         }
18787         if (flags & NDR_OUT) {
18788                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18789         }
18790         return NDR_ERR_SUCCESS;
18791 }
18792
18793 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
18794 {
18795         uint32_t _ptr_ctr;
18796         TALLOC_CTX *_mem_save_handle_0;
18797         TALLOC_CTX *_mem_save_ctr_0;
18798         if (flags & NDR_IN) {
18799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18800                         NDR_PULL_ALLOC(ndr, r->in.handle);
18801                 }
18802                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18804                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
18808                 if (_ptr_ctr) {
18809                         NDR_PULL_ALLOC(ndr, r->in.ctr);
18810                 } else {
18811                         r->in.ctr = NULL;
18812                 }
18813                 if (r->in.ctr) {
18814                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18815                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
18816                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18817                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
18818                 }
18819                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
18820         }
18821         if (flags & NDR_OUT) {
18822                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18823         }
18824         return NDR_ERR_SUCCESS;
18825 }
18826
18827 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
18828 {
18829         ndr_print_struct(ndr, name, "spoolss_SetJob");
18830         ndr->depth++;
18831         if (flags & NDR_SET_VALUES) {
18832                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18833         }
18834         if (flags & NDR_IN) {
18835                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
18836                 ndr->depth++;
18837                 ndr_print_ptr(ndr, "handle", r->in.handle);
18838                 ndr->depth++;
18839                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18840                 ndr->depth--;
18841                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18842                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
18843                 ndr->depth++;
18844                 if (r->in.ctr) {
18845                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
18846                 }
18847                 ndr->depth--;
18848                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
18849                 ndr->depth--;
18850         }
18851         if (flags & NDR_OUT) {
18852                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
18853                 ndr->depth++;
18854                 ndr_print_WERROR(ndr, "result", r->out.result);
18855                 ndr->depth--;
18856         }
18857         ndr->depth--;
18858 }
18859
18860 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
18861 {
18862         if (flags & NDR_IN) {
18863                 if (r->in.handle == NULL) {
18864                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18865                 }
18866                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18870                 if (r->in.buffer) {
18871                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18872                 }
18873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18874         }
18875         if (flags & NDR_OUT) {
18876                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18877                 if (r->out.info) {
18878                         {
18879                                 struct ndr_push *_ndr_info;
18880                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18881                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18882                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18883                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18884                         }
18885                 }
18886                 if (r->out.needed == NULL) {
18887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18888                 }
18889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18891         }
18892         return NDR_ERR_SUCCESS;
18893 }
18894
18895 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
18896 {
18897         uint32_t _ptr_buffer;
18898         uint32_t _ptr_info;
18899         TALLOC_CTX *_mem_save_handle_0;
18900         TALLOC_CTX *_mem_save_buffer_0;
18901         TALLOC_CTX *_mem_save_info_0;
18902         TALLOC_CTX *_mem_save_needed_0;
18903         if (flags & NDR_IN) {
18904                 ZERO_STRUCT(r->out);
18905
18906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18907                         NDR_PULL_ALLOC(ndr, r->in.handle);
18908                 }
18909                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18910                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18911                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18916                 if (_ptr_buffer) {
18917                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18918                 } else {
18919                         r->in.buffer = NULL;
18920                 }
18921                 if (r->in.buffer) {
18922                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18923                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18924                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18926                 }
18927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18928                 NDR_PULL_ALLOC(ndr, r->out.needed);
18929                 ZERO_STRUCTP(r->out.needed);
18930         }
18931         if (flags & NDR_OUT) {
18932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18933                 if (_ptr_info) {
18934                         NDR_PULL_ALLOC(ndr, r->out.info);
18935                 } else {
18936                         r->out.info = NULL;
18937                 }
18938                 if (r->out.info) {
18939                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18940                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18941                         {
18942                                 struct ndr_pull *_ndr_info;
18943                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18944                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18945                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18946                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18947                         }
18948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18949                 }
18950                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18951                         NDR_PULL_ALLOC(ndr, r->out.needed);
18952                 }
18953                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18954                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18956                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18957                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18958         }
18959         return NDR_ERR_SUCCESS;
18960 }
18961
18962 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
18963 {
18964         ndr_print_struct(ndr, name, "spoolss_GetJob");
18965         ndr->depth++;
18966         if (flags & NDR_SET_VALUES) {
18967                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18968         }
18969         if (flags & NDR_IN) {
18970                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
18971                 ndr->depth++;
18972                 ndr_print_ptr(ndr, "handle", r->in.handle);
18973                 ndr->depth++;
18974                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18975                 ndr->depth--;
18976                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18977                 ndr_print_uint32(ndr, "level", r->in.level);
18978                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18979                 ndr->depth++;
18980                 if (r->in.buffer) {
18981                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18982                 }
18983                 ndr->depth--;
18984                 ndr_print_uint32(ndr, "offered", r->in.offered);
18985                 ndr->depth--;
18986         }
18987         if (flags & NDR_OUT) {
18988                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
18989                 ndr->depth++;
18990                 ndr_print_ptr(ndr, "info", r->out.info);
18991                 ndr->depth++;
18992                 if (r->out.info) {
18993                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
18994                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
18995                 }
18996                 ndr->depth--;
18997                 ndr_print_ptr(ndr, "needed", r->out.needed);
18998                 ndr->depth++;
18999                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19000                 ndr->depth--;
19001                 ndr_print_WERROR(ndr, "result", r->out.result);
19002                 ndr->depth--;
19003         }
19004         ndr->depth--;
19005 }
19006
19007 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19008 {
19009         if (flags & NDR_IN) {
19010                 if (r->in.handle == NULL) {
19011                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19012                 }
19013                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19018                 if (r->in.buffer) {
19019                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19020                 }
19021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19022         }
19023         if (flags & NDR_OUT) {
19024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19025                 if (r->out.info) {
19026                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19027                 }
19028                 if (r->out.needed == NULL) {
19029                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19030                 }
19031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19032                 if (r->out.count == NULL) {
19033                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19034                 }
19035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19036                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19037         }
19038         return NDR_ERR_SUCCESS;
19039 }
19040
19041 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19042 {
19043         uint32_t _ptr_buffer;
19044         uint32_t _ptr_info;
19045         TALLOC_CTX *_mem_save_handle_0;
19046         TALLOC_CTX *_mem_save_buffer_0;
19047         TALLOC_CTX *_mem_save_info_0;
19048         TALLOC_CTX *_mem_save_needed_0;
19049         TALLOC_CTX *_mem_save_count_0;
19050         if (flags & NDR_IN) {
19051                 ZERO_STRUCT(r->out);
19052
19053                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19054                         NDR_PULL_ALLOC(ndr, r->in.handle);
19055                 }
19056                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19057                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19058                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19059                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19064                 if (_ptr_buffer) {
19065                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19066                 } else {
19067                         r->in.buffer = NULL;
19068                 }
19069                 if (r->in.buffer) {
19070                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19071                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19072                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19074                 }
19075                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19076                 NDR_PULL_ALLOC(ndr, r->out.needed);
19077                 ZERO_STRUCTP(r->out.needed);
19078                 NDR_PULL_ALLOC(ndr, r->out.count);
19079                 ZERO_STRUCTP(r->out.count);
19080         }
19081         if (flags & NDR_OUT) {
19082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19083                 if (_ptr_info) {
19084                         NDR_PULL_ALLOC(ndr, r->out.info);
19085                 } else {
19086                         r->out.info = NULL;
19087                 }
19088                 if (r->out.info) {
19089                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19090                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19091                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19093                 }
19094                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19095                         NDR_PULL_ALLOC(ndr, r->out.needed);
19096                 }
19097                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19098                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19099                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19100                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19101                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19102                         NDR_PULL_ALLOC(ndr, r->out.count);
19103                 }
19104                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19105                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19108                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19109         }
19110         return NDR_ERR_SUCCESS;
19111 }
19112
19113 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19114 {
19115         uint32_t cntr_info_0;
19116         if (flags & NDR_IN) {
19117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19119         }
19120         if (flags & NDR_OUT) {
19121                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19122                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19123                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19124                 }
19125                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19126                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19127                 }
19128         }
19129         return NDR_ERR_SUCCESS;
19130 }
19131
19132 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19133 {
19134         uint32_t cntr_info_0;
19135         TALLOC_CTX *_mem_save_info_0;
19136         if (flags & NDR_IN) {
19137                 ZERO_STRUCT(r->out);
19138
19139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19141         }
19142         if (flags & NDR_OUT) {
19143                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19144                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19145                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19146                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19147                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19148                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19149                 }
19150                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19151                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19152                 }
19153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19154         }
19155         return NDR_ERR_SUCCESS;
19156 }
19157
19158 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19159 {
19160         uint32_t cntr_info_2;
19161         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19162         ndr->depth++;
19163         if (flags & NDR_SET_VALUES) {
19164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19165         }
19166         if (flags & NDR_IN) {
19167                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19168                 ndr->depth++;
19169                 ndr_print_ptr(ndr, "handle", r->in.handle);
19170                 ndr->depth++;
19171                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19172                 ndr->depth--;
19173                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19174                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19175                 ndr_print_uint32(ndr, "level", r->in.level);
19176                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19177                 ndr->depth++;
19178                 if (r->in.buffer) {
19179                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19180                 }
19181                 ndr->depth--;
19182                 ndr_print_uint32(ndr, "offered", r->in.offered);
19183                 ndr->depth--;
19184         }
19185         if (flags & NDR_OUT) {
19186                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19187                 ndr->depth++;
19188                 ndr_print_ptr(ndr, "count", r->out.count);
19189                 ndr->depth++;
19190                 ndr_print_uint32(ndr, "count", *r->out.count);
19191                 ndr->depth--;
19192                 ndr_print_ptr(ndr, "info", r->out.info);
19193                 ndr->depth++;
19194                 ndr_print_ptr(ndr, "info", *r->out.info);
19195                 ndr->depth++;
19196                 if (*r->out.info) {
19197                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19198                         ndr->depth++;
19199                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19200                                 char *idx_2=NULL;
19201                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19202                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19203                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19204                                         free(idx_2);
19205                                 }
19206                         }
19207                         ndr->depth--;
19208                 }
19209                 ndr->depth--;
19210                 ndr->depth--;
19211                 ndr_print_ptr(ndr, "needed", r->out.needed);
19212                 ndr->depth++;
19213                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19214                 ndr->depth--;
19215                 ndr_print_WERROR(ndr, "result", r->out.result);
19216                 ndr->depth--;
19217         }
19218         ndr->depth--;
19219 }
19220
19221 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19222 {
19223         if (flags & NDR_IN) {
19224         }
19225         if (flags & NDR_OUT) {
19226                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19227         }
19228         return NDR_ERR_SUCCESS;
19229 }
19230
19231 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19232 {
19233         if (flags & NDR_IN) {
19234         }
19235         if (flags & NDR_OUT) {
19236                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19237         }
19238         return NDR_ERR_SUCCESS;
19239 }
19240
19241 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19242 {
19243         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19244         ndr->depth++;
19245         if (flags & NDR_SET_VALUES) {
19246                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19247         }
19248         if (flags & NDR_IN) {
19249                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19250                 ndr->depth++;
19251                 ndr->depth--;
19252         }
19253         if (flags & NDR_OUT) {
19254                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19255                 ndr->depth++;
19256                 ndr_print_WERROR(ndr, "result", r->out.result);
19257                 ndr->depth--;
19258         }
19259         ndr->depth--;
19260 }
19261
19262 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19263 {
19264         if (flags & NDR_IN) {
19265                 if (r->in.handle == NULL) {
19266                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19267                 }
19268                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19269         }
19270         if (flags & NDR_OUT) {
19271                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19272         }
19273         return NDR_ERR_SUCCESS;
19274 }
19275
19276 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19277 {
19278         TALLOC_CTX *_mem_save_handle_0;
19279         if (flags & NDR_IN) {
19280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19281                         NDR_PULL_ALLOC(ndr, r->in.handle);
19282                 }
19283                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19284                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19285                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19287         }
19288         if (flags & NDR_OUT) {
19289                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19290         }
19291         return NDR_ERR_SUCCESS;
19292 }
19293
19294 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19295 {
19296         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19297         ndr->depth++;
19298         if (flags & NDR_SET_VALUES) {
19299                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19300         }
19301         if (flags & NDR_IN) {
19302                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19303                 ndr->depth++;
19304                 ndr_print_ptr(ndr, "handle", r->in.handle);
19305                 ndr->depth++;
19306                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19307                 ndr->depth--;
19308                 ndr->depth--;
19309         }
19310         if (flags & NDR_OUT) {
19311                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19312                 ndr->depth++;
19313                 ndr_print_WERROR(ndr, "result", r->out.result);
19314                 ndr->depth--;
19315         }
19316         ndr->depth--;
19317 }
19318
19319 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19320 {
19321         if (flags & NDR_IN) {
19322                 if (r->in.handle == NULL) {
19323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19324                 }
19325                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19326                 if (r->in.info_ctr == NULL) {
19327                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19328                 }
19329                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19330                 if (r->in.devmode_ctr == NULL) {
19331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19332                 }
19333                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19334                 if (r->in.secdesc_ctr == NULL) {
19335                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19336                 }
19337                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19338                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19339         }
19340         if (flags & NDR_OUT) {
19341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19342         }
19343         return NDR_ERR_SUCCESS;
19344 }
19345
19346 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19347 {
19348         TALLOC_CTX *_mem_save_handle_0;
19349         TALLOC_CTX *_mem_save_info_ctr_0;
19350         TALLOC_CTX *_mem_save_devmode_ctr_0;
19351         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19352         if (flags & NDR_IN) {
19353                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19354                         NDR_PULL_ALLOC(ndr, r->in.handle);
19355                 }
19356                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19357                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19358                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19359                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19361                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19362                 }
19363                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19364                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19365                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19368                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19369                 }
19370                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19371                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19372                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19375                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19376                 }
19377                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19378                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19379                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19381                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19382         }
19383         if (flags & NDR_OUT) {
19384                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19385         }
19386         return NDR_ERR_SUCCESS;
19387 }
19388
19389 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19390 {
19391         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19392         ndr->depth++;
19393         if (flags & NDR_SET_VALUES) {
19394                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19395         }
19396         if (flags & NDR_IN) {
19397                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19398                 ndr->depth++;
19399                 ndr_print_ptr(ndr, "handle", r->in.handle);
19400                 ndr->depth++;
19401                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19402                 ndr->depth--;
19403                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19404                 ndr->depth++;
19405                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19406                 ndr->depth--;
19407                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19408                 ndr->depth++;
19409                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19410                 ndr->depth--;
19411                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19412                 ndr->depth++;
19413                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19414                 ndr->depth--;
19415                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19416                 ndr->depth--;
19417         }
19418         if (flags & NDR_OUT) {
19419                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19420                 ndr->depth++;
19421                 ndr_print_WERROR(ndr, "result", r->out.result);
19422                 ndr->depth--;
19423         }
19424         ndr->depth--;
19425 }
19426
19427 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19428 {
19429         if (flags & NDR_IN) {
19430                 if (r->in.handle == NULL) {
19431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19432                 }
19433                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19435                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19436                 if (r->in.buffer) {
19437                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19438                 }
19439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19440         }
19441         if (flags & NDR_OUT) {
19442                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19443                 if (r->out.info) {
19444                         {
19445                                 struct ndr_push *_ndr_info;
19446                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19447                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19448                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19449                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19450                         }
19451                 }
19452                 if (r->out.needed == NULL) {
19453                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19454                 }
19455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19456                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19457         }
19458         return NDR_ERR_SUCCESS;
19459 }
19460
19461 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19462 {
19463         uint32_t _ptr_buffer;
19464         uint32_t _ptr_info;
19465         TALLOC_CTX *_mem_save_handle_0;
19466         TALLOC_CTX *_mem_save_buffer_0;
19467         TALLOC_CTX *_mem_save_info_0;
19468         TALLOC_CTX *_mem_save_needed_0;
19469         if (flags & NDR_IN) {
19470                 ZERO_STRUCT(r->out);
19471
19472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19473                         NDR_PULL_ALLOC(ndr, r->in.handle);
19474                 }
19475                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19477                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19481                 if (_ptr_buffer) {
19482                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19483                 } else {
19484                         r->in.buffer = NULL;
19485                 }
19486                 if (r->in.buffer) {
19487                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19488                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19489                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19490                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19491                 }
19492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19493                 NDR_PULL_ALLOC(ndr, r->out.needed);
19494                 ZERO_STRUCTP(r->out.needed);
19495         }
19496         if (flags & NDR_OUT) {
19497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19498                 if (_ptr_info) {
19499                         NDR_PULL_ALLOC(ndr, r->out.info);
19500                 } else {
19501                         r->out.info = NULL;
19502                 }
19503                 if (r->out.info) {
19504                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19505                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19506                         {
19507                                 struct ndr_pull *_ndr_info;
19508                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19509                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19510                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19511                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19512                         }
19513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19514                 }
19515                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19516                         NDR_PULL_ALLOC(ndr, r->out.needed);
19517                 }
19518                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19519                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19522                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19523         }
19524         return NDR_ERR_SUCCESS;
19525 }
19526
19527 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19528 {
19529         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19530         ndr->depth++;
19531         if (flags & NDR_SET_VALUES) {
19532                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19533         }
19534         if (flags & NDR_IN) {
19535                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19536                 ndr->depth++;
19537                 ndr_print_ptr(ndr, "handle", r->in.handle);
19538                 ndr->depth++;
19539                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19540                 ndr->depth--;
19541                 ndr_print_uint32(ndr, "level", r->in.level);
19542                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19543                 ndr->depth++;
19544                 if (r->in.buffer) {
19545                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19546                 }
19547                 ndr->depth--;
19548                 ndr_print_uint32(ndr, "offered", r->in.offered);
19549                 ndr->depth--;
19550         }
19551         if (flags & NDR_OUT) {
19552                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19553                 ndr->depth++;
19554                 ndr_print_ptr(ndr, "info", r->out.info);
19555                 ndr->depth++;
19556                 if (r->out.info) {
19557                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19558                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19559                 }
19560                 ndr->depth--;
19561                 ndr_print_ptr(ndr, "needed", r->out.needed);
19562                 ndr->depth++;
19563                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19564                 ndr->depth--;
19565                 ndr_print_WERROR(ndr, "result", r->out.result);
19566                 ndr->depth--;
19567         }
19568         ndr->depth--;
19569 }
19570
19571 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19572 {
19573         if (flags & NDR_IN) {
19574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19575                 if (r->in.servername) {
19576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19577                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19578                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19579                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19580                 }
19581                 if (r->in.info_ctr == NULL) {
19582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19583                 }
19584                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19585         }
19586         if (flags & NDR_OUT) {
19587                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19588         }
19589         return NDR_ERR_SUCCESS;
19590 }
19591
19592 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19593 {
19594         uint32_t _ptr_servername;
19595         TALLOC_CTX *_mem_save_servername_0;
19596         TALLOC_CTX *_mem_save_info_ctr_0;
19597         if (flags & NDR_IN) {
19598                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19599                 if (_ptr_servername) {
19600                         NDR_PULL_ALLOC(ndr, r->in.servername);
19601                 } else {
19602                         r->in.servername = NULL;
19603                 }
19604                 if (r->in.servername) {
19605                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19606                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19609                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19610                                 return 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));
19611                         }
19612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19615                 }
19616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19617                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19618                 }
19619                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19620                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19621                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19623         }
19624         if (flags & NDR_OUT) {
19625                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19626         }
19627         return NDR_ERR_SUCCESS;
19628 }
19629
19630 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19631 {
19632         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19633         ndr->depth++;
19634         if (flags & NDR_SET_VALUES) {
19635                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19636         }
19637         if (flags & NDR_IN) {
19638                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19639                 ndr->depth++;
19640                 ndr_print_ptr(ndr, "servername", r->in.servername);
19641                 ndr->depth++;
19642                 if (r->in.servername) {
19643                         ndr_print_string(ndr, "servername", r->in.servername);
19644                 }
19645                 ndr->depth--;
19646                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19647                 ndr->depth++;
19648                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19649                 ndr->depth--;
19650                 ndr->depth--;
19651         }
19652         if (flags & NDR_OUT) {
19653                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19654                 ndr->depth++;
19655                 ndr_print_WERROR(ndr, "result", r->out.result);
19656                 ndr->depth--;
19657         }
19658         ndr->depth--;
19659 }
19660
19661 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19662 {
19663         if (flags & NDR_IN) {
19664                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19665                 if (r->in.server) {
19666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19670                 }
19671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19672                 if (r->in.environment) {
19673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19676                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19677                 }
19678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19680                 if (r->in.buffer) {
19681                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19682                 }
19683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19684         }
19685         if (flags & NDR_OUT) {
19686                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19687                 if (r->out.info) {
19688                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19689                 }
19690                 if (r->out.needed == NULL) {
19691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19692                 }
19693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19694                 if (r->out.count == NULL) {
19695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19696                 }
19697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19698                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19699         }
19700         return NDR_ERR_SUCCESS;
19701 }
19702
19703 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19704 {
19705         uint32_t _ptr_server;
19706         uint32_t _ptr_environment;
19707         uint32_t _ptr_buffer;
19708         uint32_t _ptr_info;
19709         TALLOC_CTX *_mem_save_server_0;
19710         TALLOC_CTX *_mem_save_environment_0;
19711         TALLOC_CTX *_mem_save_buffer_0;
19712         TALLOC_CTX *_mem_save_info_0;
19713         TALLOC_CTX *_mem_save_needed_0;
19714         TALLOC_CTX *_mem_save_count_0;
19715         if (flags & NDR_IN) {
19716                 ZERO_STRUCT(r->out);
19717
19718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19719                 if (_ptr_server) {
19720                         NDR_PULL_ALLOC(ndr, r->in.server);
19721                 } else {
19722                         r->in.server = NULL;
19723                 }
19724                 if (r->in.server) {
19725                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19727                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19728                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19729                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19730                                 return 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));
19731                         }
19732                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19733                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19734                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19735                 }
19736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19737                 if (_ptr_environment) {
19738                         NDR_PULL_ALLOC(ndr, r->in.environment);
19739                 } else {
19740                         r->in.environment = NULL;
19741                 }
19742                 if (r->in.environment) {
19743                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19744                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19745                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19746                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19747                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19748                                 return 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));
19749                         }
19750                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19751                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19753                 }
19754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19756                 if (_ptr_buffer) {
19757                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19758                 } else {
19759                         r->in.buffer = NULL;
19760                 }
19761                 if (r->in.buffer) {
19762                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19763                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19764                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19766                 }
19767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19768                 NDR_PULL_ALLOC(ndr, r->out.needed);
19769                 ZERO_STRUCTP(r->out.needed);
19770                 NDR_PULL_ALLOC(ndr, r->out.count);
19771                 ZERO_STRUCTP(r->out.count);
19772         }
19773         if (flags & NDR_OUT) {
19774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19775                 if (_ptr_info) {
19776                         NDR_PULL_ALLOC(ndr, r->out.info);
19777                 } else {
19778                         r->out.info = NULL;
19779                 }
19780                 if (r->out.info) {
19781                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19782                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19783                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19785                 }
19786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19787                         NDR_PULL_ALLOC(ndr, r->out.needed);
19788                 }
19789                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19790                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19793                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19794                         NDR_PULL_ALLOC(ndr, r->out.count);
19795                 }
19796                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19797                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19799                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19800                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19801         }
19802         return NDR_ERR_SUCCESS;
19803 }
19804
19805 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
19806 {
19807         uint32_t cntr_info_0;
19808         if (flags & NDR_IN) {
19809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19811         }
19812         if (flags & NDR_OUT) {
19813                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19814                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19815                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19816                 }
19817                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19818                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19819                 }
19820         }
19821         return NDR_ERR_SUCCESS;
19822 }
19823
19824 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
19825 {
19826         uint32_t cntr_info_0;
19827         TALLOC_CTX *_mem_save_info_0;
19828         if (flags & NDR_IN) {
19829                 ZERO_STRUCT(r->out);
19830
19831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19833         }
19834         if (flags & NDR_OUT) {
19835                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19836                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19837                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19838                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19839                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19840                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19841                 }
19842                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19843                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19844                 }
19845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19846         }
19847         return NDR_ERR_SUCCESS;
19848 }
19849
19850 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
19851 {
19852         uint32_t cntr_info_2;
19853         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
19854         ndr->depth++;
19855         if (flags & NDR_SET_VALUES) {
19856                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19857         }
19858         if (flags & NDR_IN) {
19859                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
19860                 ndr->depth++;
19861                 ndr_print_ptr(ndr, "server", r->in.server);
19862                 ndr->depth++;
19863                 if (r->in.server) {
19864                         ndr_print_string(ndr, "server", r->in.server);
19865                 }
19866                 ndr->depth--;
19867                 ndr_print_ptr(ndr, "environment", r->in.environment);
19868                 ndr->depth++;
19869                 if (r->in.environment) {
19870                         ndr_print_string(ndr, "environment", r->in.environment);
19871                 }
19872                 ndr->depth--;
19873                 ndr_print_uint32(ndr, "level", r->in.level);
19874                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19875                 ndr->depth++;
19876                 if (r->in.buffer) {
19877                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19878                 }
19879                 ndr->depth--;
19880                 ndr_print_uint32(ndr, "offered", r->in.offered);
19881                 ndr->depth--;
19882         }
19883         if (flags & NDR_OUT) {
19884                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
19885                 ndr->depth++;
19886                 ndr_print_ptr(ndr, "count", r->out.count);
19887                 ndr->depth++;
19888                 ndr_print_uint32(ndr, "count", *r->out.count);
19889                 ndr->depth--;
19890                 ndr_print_ptr(ndr, "info", r->out.info);
19891                 ndr->depth++;
19892                 ndr_print_ptr(ndr, "info", *r->out.info);
19893                 ndr->depth++;
19894                 if (*r->out.info) {
19895                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19896                         ndr->depth++;
19897                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19898                                 char *idx_2=NULL;
19899                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19900                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19901                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19902                                         free(idx_2);
19903                                 }
19904                         }
19905                         ndr->depth--;
19906                 }
19907                 ndr->depth--;
19908                 ndr->depth--;
19909                 ndr_print_ptr(ndr, "needed", r->out.needed);
19910                 ndr->depth++;
19911                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19912                 ndr->depth--;
19913                 ndr_print_WERROR(ndr, "result", r->out.result);
19914                 ndr->depth--;
19915         }
19916         ndr->depth--;
19917 }
19918
19919 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
19920 {
19921         if (flags & NDR_IN) {
19922         }
19923         if (flags & NDR_OUT) {
19924                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19925         }
19926         return NDR_ERR_SUCCESS;
19927 }
19928
19929 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
19930 {
19931         if (flags & NDR_IN) {
19932         }
19933         if (flags & NDR_OUT) {
19934                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19935         }
19936         return NDR_ERR_SUCCESS;
19937 }
19938
19939 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
19940 {
19941         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
19942         ndr->depth++;
19943         if (flags & NDR_SET_VALUES) {
19944                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19945         }
19946         if (flags & NDR_IN) {
19947                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
19948                 ndr->depth++;
19949                 ndr->depth--;
19950         }
19951         if (flags & NDR_OUT) {
19952                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
19953                 ndr->depth++;
19954                 ndr_print_WERROR(ndr, "result", r->out.result);
19955                 ndr->depth--;
19956         }
19957         ndr->depth--;
19958 }
19959
19960 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
19961 {
19962         if (flags & NDR_IN) {
19963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19964                 if (r->in.server) {
19965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19968                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19969                 }
19970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19971                 if (r->in.environment) {
19972                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19976                 }
19977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19979                 if (r->in.buffer) {
19980                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19981                 }
19982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19983         }
19984         if (flags & NDR_OUT) {
19985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19986                 if (r->out.info) {
19987                         {
19988                                 struct ndr_push *_ndr_info;
19989                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19990                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19991                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
19992                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19993                         }
19994                 }
19995                 if (r->out.needed == NULL) {
19996                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19997                 }
19998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19999                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20000         }
20001         return NDR_ERR_SUCCESS;
20002 }
20003
20004 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20005 {
20006         uint32_t _ptr_server;
20007         uint32_t _ptr_environment;
20008         uint32_t _ptr_buffer;
20009         uint32_t _ptr_info;
20010         TALLOC_CTX *_mem_save_server_0;
20011         TALLOC_CTX *_mem_save_environment_0;
20012         TALLOC_CTX *_mem_save_buffer_0;
20013         TALLOC_CTX *_mem_save_info_0;
20014         TALLOC_CTX *_mem_save_needed_0;
20015         if (flags & NDR_IN) {
20016                 ZERO_STRUCT(r->out);
20017
20018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20019                 if (_ptr_server) {
20020                         NDR_PULL_ALLOC(ndr, r->in.server);
20021                 } else {
20022                         r->in.server = NULL;
20023                 }
20024                 if (r->in.server) {
20025                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20026                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20027                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20028                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20029                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20030                                 return 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));
20031                         }
20032                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20033                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20034                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20035                 }
20036                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20037                 if (_ptr_environment) {
20038                         NDR_PULL_ALLOC(ndr, r->in.environment);
20039                 } else {
20040                         r->in.environment = NULL;
20041                 }
20042                 if (r->in.environment) {
20043                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20044                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20047                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20048                                 return 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));
20049                         }
20050                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20051                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20053                 }
20054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20056                 if (_ptr_buffer) {
20057                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20058                 } else {
20059                         r->in.buffer = NULL;
20060                 }
20061                 if (r->in.buffer) {
20062                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20063                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20064                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20066                 }
20067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20068                 NDR_PULL_ALLOC(ndr, r->out.needed);
20069                 ZERO_STRUCTP(r->out.needed);
20070         }
20071         if (flags & NDR_OUT) {
20072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20073                 if (_ptr_info) {
20074                         NDR_PULL_ALLOC(ndr, r->out.info);
20075                 } else {
20076                         r->out.info = NULL;
20077                 }
20078                 if (r->out.info) {
20079                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20080                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20081                         {
20082                                 struct ndr_pull *_ndr_info;
20083                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20084                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20085                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20086                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20087                         }
20088                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20089                 }
20090                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20091                         NDR_PULL_ALLOC(ndr, r->out.needed);
20092                 }
20093                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20094                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20097                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20098         }
20099         return NDR_ERR_SUCCESS;
20100 }
20101
20102 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20103 {
20104         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20105         ndr->depth++;
20106         if (flags & NDR_SET_VALUES) {
20107                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20108         }
20109         if (flags & NDR_IN) {
20110                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20111                 ndr->depth++;
20112                 ndr_print_ptr(ndr, "server", r->in.server);
20113                 ndr->depth++;
20114                 if (r->in.server) {
20115                         ndr_print_string(ndr, "server", r->in.server);
20116                 }
20117                 ndr->depth--;
20118                 ndr_print_ptr(ndr, "environment", r->in.environment);
20119                 ndr->depth++;
20120                 if (r->in.environment) {
20121                         ndr_print_string(ndr, "environment", r->in.environment);
20122                 }
20123                 ndr->depth--;
20124                 ndr_print_uint32(ndr, "level", r->in.level);
20125                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20126                 ndr->depth++;
20127                 if (r->in.buffer) {
20128                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20129                 }
20130                 ndr->depth--;
20131                 ndr_print_uint32(ndr, "offered", r->in.offered);
20132                 ndr->depth--;
20133         }
20134         if (flags & NDR_OUT) {
20135                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20136                 ndr->depth++;
20137                 ndr_print_ptr(ndr, "info", r->out.info);
20138                 ndr->depth++;
20139                 if (r->out.info) {
20140                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20141                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20142                 }
20143                 ndr->depth--;
20144                 ndr_print_ptr(ndr, "needed", r->out.needed);
20145                 ndr->depth++;
20146                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20147                 ndr->depth--;
20148                 ndr_print_WERROR(ndr, "result", r->out.result);
20149                 ndr->depth--;
20150         }
20151         ndr->depth--;
20152 }
20153
20154 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20155 {
20156         if (flags & NDR_IN) {
20157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20158                 if (r->in.server) {
20159                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20160                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20161                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20162                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20163                 }
20164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20167                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20171                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20172         }
20173         if (flags & NDR_OUT) {
20174                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20175         }
20176         return NDR_ERR_SUCCESS;
20177 }
20178
20179 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20180 {
20181         uint32_t _ptr_server;
20182         TALLOC_CTX *_mem_save_server_0;
20183         if (flags & NDR_IN) {
20184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20185                 if (_ptr_server) {
20186                         NDR_PULL_ALLOC(ndr, r->in.server);
20187                 } else {
20188                         r->in.server = NULL;
20189                 }
20190                 if (r->in.server) {
20191                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20192                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20194                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20195                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20196                                 return 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));
20197                         }
20198                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20199                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20201                 }
20202                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20203                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20204                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20205                         return 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));
20206                 }
20207                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20208                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20209                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20210                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20211                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20212                         return 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));
20213                 }
20214                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20215                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20216         }
20217         if (flags & NDR_OUT) {
20218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20219         }
20220         return NDR_ERR_SUCCESS;
20221 }
20222
20223 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20224 {
20225         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20226         ndr->depth++;
20227         if (flags & NDR_SET_VALUES) {
20228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20229         }
20230         if (flags & NDR_IN) {
20231                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20232                 ndr->depth++;
20233                 ndr_print_ptr(ndr, "server", r->in.server);
20234                 ndr->depth++;
20235                 if (r->in.server) {
20236                         ndr_print_string(ndr, "server", r->in.server);
20237                 }
20238                 ndr->depth--;
20239                 ndr_print_string(ndr, "architecture", r->in.architecture);
20240                 ndr_print_string(ndr, "driver", r->in.driver);
20241                 ndr->depth--;
20242         }
20243         if (flags & NDR_OUT) {
20244                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20245                 ndr->depth++;
20246                 ndr_print_WERROR(ndr, "result", r->out.result);
20247                 ndr->depth--;
20248         }
20249         ndr->depth--;
20250 }
20251
20252 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20253 {
20254         if (flags & NDR_IN) {
20255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20256                 if (r->in.server) {
20257                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20258                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20259                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20260                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20261                 }
20262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20265                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20269                 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));
20270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20273                 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));
20274         }
20275         if (flags & NDR_OUT) {
20276                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20277         }
20278         return NDR_ERR_SUCCESS;
20279 }
20280
20281 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20282 {
20283         uint32_t _ptr_server;
20284         TALLOC_CTX *_mem_save_server_0;
20285         if (flags & NDR_IN) {
20286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20287                 if (_ptr_server) {
20288                         NDR_PULL_ALLOC(ndr, r->in.server);
20289                 } else {
20290                         r->in.server = NULL;
20291                 }
20292                 if (r->in.server) {
20293                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20294                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20295                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20296                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20297                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20298                                 return 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));
20299                         }
20300                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20301                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20303                 }
20304                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20305                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20306                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20307                         return 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));
20308                 }
20309                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20310                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20311                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20312                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20313                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20314                         return 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));
20315                 }
20316                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20317                 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));
20318                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20319                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20320                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20321                         return 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));
20322                 }
20323                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20324                 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));
20325         }
20326         if (flags & NDR_OUT) {
20327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20328         }
20329         return NDR_ERR_SUCCESS;
20330 }
20331
20332 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20333 {
20334         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20335         ndr->depth++;
20336         if (flags & NDR_SET_VALUES) {
20337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20338         }
20339         if (flags & NDR_IN) {
20340                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20341                 ndr->depth++;
20342                 ndr_print_ptr(ndr, "server", r->in.server);
20343                 ndr->depth++;
20344                 if (r->in.server) {
20345                         ndr_print_string(ndr, "server", r->in.server);
20346                 }
20347                 ndr->depth--;
20348                 ndr_print_string(ndr, "architecture", r->in.architecture);
20349                 ndr_print_string(ndr, "path_name", r->in.path_name);
20350                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20351                 ndr->depth--;
20352         }
20353         if (flags & NDR_OUT) {
20354                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20355                 ndr->depth++;
20356                 ndr_print_WERROR(ndr, "result", r->out.result);
20357                 ndr->depth--;
20358         }
20359         ndr->depth--;
20360 }
20361
20362 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20363 {
20364         if (flags & NDR_IN) {
20365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20366                 if (r->in.servername) {
20367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20371                 }
20372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20373                 if (r->in.environment) {
20374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20378                 }
20379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20381                 if (r->in.buffer) {
20382                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20383                 }
20384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20385         }
20386         if (flags & NDR_OUT) {
20387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20388                 if (r->out.info) {
20389                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20390                 }
20391                 if (r->out.needed == NULL) {
20392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20393                 }
20394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20395                 if (r->out.count == NULL) {
20396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20397                 }
20398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20399                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20400         }
20401         return NDR_ERR_SUCCESS;
20402 }
20403
20404 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20405 {
20406         uint32_t _ptr_servername;
20407         uint32_t _ptr_environment;
20408         uint32_t _ptr_buffer;
20409         uint32_t _ptr_info;
20410         TALLOC_CTX *_mem_save_servername_0;
20411         TALLOC_CTX *_mem_save_environment_0;
20412         TALLOC_CTX *_mem_save_buffer_0;
20413         TALLOC_CTX *_mem_save_info_0;
20414         TALLOC_CTX *_mem_save_needed_0;
20415         TALLOC_CTX *_mem_save_count_0;
20416         if (flags & NDR_IN) {
20417                 ZERO_STRUCT(r->out);
20418
20419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20420                 if (_ptr_servername) {
20421                         NDR_PULL_ALLOC(ndr, r->in.servername);
20422                 } else {
20423                         r->in.servername = NULL;
20424                 }
20425                 if (r->in.servername) {
20426                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20427                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20428                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20429                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20430                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20431                                 return 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));
20432                         }
20433                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20434                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20436                 }
20437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20438                 if (_ptr_environment) {
20439                         NDR_PULL_ALLOC(ndr, r->in.environment);
20440                 } else {
20441                         r->in.environment = NULL;
20442                 }
20443                 if (r->in.environment) {
20444                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20445                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20446                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20447                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20448                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20449                                 return 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));
20450                         }
20451                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20452                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20454                 }
20455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20457                 if (_ptr_buffer) {
20458                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20459                 } else {
20460                         r->in.buffer = NULL;
20461                 }
20462                 if (r->in.buffer) {
20463                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20464                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20465                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20466                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20467                 }
20468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20469                 NDR_PULL_ALLOC(ndr, r->out.needed);
20470                 ZERO_STRUCTP(r->out.needed);
20471                 NDR_PULL_ALLOC(ndr, r->out.count);
20472                 ZERO_STRUCTP(r->out.count);
20473         }
20474         if (flags & NDR_OUT) {
20475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20476                 if (_ptr_info) {
20477                         NDR_PULL_ALLOC(ndr, r->out.info);
20478                 } else {
20479                         r->out.info = NULL;
20480                 }
20481                 if (r->out.info) {
20482                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20483                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20484                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20486                 }
20487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20488                         NDR_PULL_ALLOC(ndr, r->out.needed);
20489                 }
20490                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20491                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20494                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20495                         NDR_PULL_ALLOC(ndr, r->out.count);
20496                 }
20497                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20498                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20501                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20502         }
20503         return NDR_ERR_SUCCESS;
20504 }
20505
20506 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20507 {
20508         uint32_t cntr_info_0;
20509         if (flags & NDR_IN) {
20510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20512         }
20513         if (flags & NDR_OUT) {
20514                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20515                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20516                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20517                 }
20518                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20519                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20520                 }
20521         }
20522         return NDR_ERR_SUCCESS;
20523 }
20524
20525 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20526 {
20527         uint32_t cntr_info_0;
20528         TALLOC_CTX *_mem_save_info_0;
20529         if (flags & NDR_IN) {
20530                 ZERO_STRUCT(r->out);
20531
20532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20534         }
20535         if (flags & NDR_OUT) {
20536                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20537                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20538                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20539                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20540                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20541                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20542                 }
20543                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20544                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20545                 }
20546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20547         }
20548         return NDR_ERR_SUCCESS;
20549 }
20550
20551 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20552 {
20553         uint32_t cntr_info_2;
20554         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20555         ndr->depth++;
20556         if (flags & NDR_SET_VALUES) {
20557                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20558         }
20559         if (flags & NDR_IN) {
20560                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20561                 ndr->depth++;
20562                 ndr_print_ptr(ndr, "servername", r->in.servername);
20563                 ndr->depth++;
20564                 if (r->in.servername) {
20565                         ndr_print_string(ndr, "servername", r->in.servername);
20566                 }
20567                 ndr->depth--;
20568                 ndr_print_ptr(ndr, "environment", r->in.environment);
20569                 ndr->depth++;
20570                 if (r->in.environment) {
20571                         ndr_print_string(ndr, "environment", r->in.environment);
20572                 }
20573                 ndr->depth--;
20574                 ndr_print_uint32(ndr, "level", r->in.level);
20575                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20576                 ndr->depth++;
20577                 if (r->in.buffer) {
20578                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20579                 }
20580                 ndr->depth--;
20581                 ndr_print_uint32(ndr, "offered", r->in.offered);
20582                 ndr->depth--;
20583         }
20584         if (flags & NDR_OUT) {
20585                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20586                 ndr->depth++;
20587                 ndr_print_ptr(ndr, "count", r->out.count);
20588                 ndr->depth++;
20589                 ndr_print_uint32(ndr, "count", *r->out.count);
20590                 ndr->depth--;
20591                 ndr_print_ptr(ndr, "info", r->out.info);
20592                 ndr->depth++;
20593                 ndr_print_ptr(ndr, "info", *r->out.info);
20594                 ndr->depth++;
20595                 if (*r->out.info) {
20596                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20597                         ndr->depth++;
20598                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20599                                 char *idx_2=NULL;
20600                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20601                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20602                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20603                                         free(idx_2);
20604                                 }
20605                         }
20606                         ndr->depth--;
20607                 }
20608                 ndr->depth--;
20609                 ndr->depth--;
20610                 ndr_print_ptr(ndr, "needed", r->out.needed);
20611                 ndr->depth++;
20612                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20613                 ndr->depth--;
20614                 ndr_print_WERROR(ndr, "result", r->out.result);
20615                 ndr->depth--;
20616         }
20617         ndr->depth--;
20618 }
20619
20620 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20621 {
20622         if (flags & NDR_IN) {
20623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20624                 if (r->in.server) {
20625                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20626                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20627                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20628                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20629                 }
20630                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20631                 if (r->in.environment) {
20632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20633                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20634                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20635                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20636                 }
20637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20639                 if (r->in.buffer) {
20640                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20641                 }
20642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20643         }
20644         if (flags & NDR_OUT) {
20645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20646                 if (r->out.info) {
20647                         {
20648                                 struct ndr_push *_ndr_info;
20649                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20650                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20651                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20652                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20653                         }
20654                 }
20655                 if (r->out.needed == NULL) {
20656                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20657                 }
20658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20659                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20660         }
20661         return NDR_ERR_SUCCESS;
20662 }
20663
20664 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20665 {
20666         uint32_t _ptr_server;
20667         uint32_t _ptr_environment;
20668         uint32_t _ptr_buffer;
20669         uint32_t _ptr_info;
20670         TALLOC_CTX *_mem_save_server_0;
20671         TALLOC_CTX *_mem_save_environment_0;
20672         TALLOC_CTX *_mem_save_buffer_0;
20673         TALLOC_CTX *_mem_save_info_0;
20674         TALLOC_CTX *_mem_save_needed_0;
20675         if (flags & NDR_IN) {
20676                 ZERO_STRUCT(r->out);
20677
20678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20679                 if (_ptr_server) {
20680                         NDR_PULL_ALLOC(ndr, r->in.server);
20681                 } else {
20682                         r->in.server = NULL;
20683                 }
20684                 if (r->in.server) {
20685                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20686                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20687                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20688                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20689                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20690                                 return 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));
20691                         }
20692                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20693                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20694                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20695                 }
20696                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20697                 if (_ptr_environment) {
20698                         NDR_PULL_ALLOC(ndr, r->in.environment);
20699                 } else {
20700                         r->in.environment = NULL;
20701                 }
20702                 if (r->in.environment) {
20703                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20704                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20705                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20706                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20707                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20708                                 return 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));
20709                         }
20710                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20711                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20712                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20713                 }
20714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20716                 if (_ptr_buffer) {
20717                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20718                 } else {
20719                         r->in.buffer = NULL;
20720                 }
20721                 if (r->in.buffer) {
20722                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20723                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20724                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20726                 }
20727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20728                 NDR_PULL_ALLOC(ndr, r->out.needed);
20729                 ZERO_STRUCTP(r->out.needed);
20730         }
20731         if (flags & NDR_OUT) {
20732                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20733                 if (_ptr_info) {
20734                         NDR_PULL_ALLOC(ndr, r->out.info);
20735                 } else {
20736                         r->out.info = NULL;
20737                 }
20738                 if (r->out.info) {
20739                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20740                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20741                         {
20742                                 struct ndr_pull *_ndr_info;
20743                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20744                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20745                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20746                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20747                         }
20748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20749                 }
20750                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20751                         NDR_PULL_ALLOC(ndr, r->out.needed);
20752                 }
20753                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20754                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20757                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20758         }
20759         return NDR_ERR_SUCCESS;
20760 }
20761
20762 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20763 {
20764         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20765         ndr->depth++;
20766         if (flags & NDR_SET_VALUES) {
20767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20768         }
20769         if (flags & NDR_IN) {
20770                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20771                 ndr->depth++;
20772                 ndr_print_ptr(ndr, "server", r->in.server);
20773                 ndr->depth++;
20774                 if (r->in.server) {
20775                         ndr_print_string(ndr, "server", r->in.server);
20776                 }
20777                 ndr->depth--;
20778                 ndr_print_ptr(ndr, "environment", r->in.environment);
20779                 ndr->depth++;
20780                 if (r->in.environment) {
20781                         ndr_print_string(ndr, "environment", r->in.environment);
20782                 }
20783                 ndr->depth--;
20784                 ndr_print_uint32(ndr, "level", r->in.level);
20785                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20786                 ndr->depth++;
20787                 if (r->in.buffer) {
20788                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20789                 }
20790                 ndr->depth--;
20791                 ndr_print_uint32(ndr, "offered", r->in.offered);
20792                 ndr->depth--;
20793         }
20794         if (flags & NDR_OUT) {
20795                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
20796                 ndr->depth++;
20797                 ndr_print_ptr(ndr, "info", r->out.info);
20798                 ndr->depth++;
20799                 if (r->out.info) {
20800                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20801                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
20802                 }
20803                 ndr->depth--;
20804                 ndr_print_ptr(ndr, "needed", r->out.needed);
20805                 ndr->depth++;
20806                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20807                 ndr->depth--;
20808                 ndr_print_WERROR(ndr, "result", r->out.result);
20809                 ndr->depth--;
20810         }
20811         ndr->depth--;
20812 }
20813
20814 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
20815 {
20816         if (flags & NDR_IN) {
20817                 if (r->in.handle == NULL) {
20818                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20819                 }
20820                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20822                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20823                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20824         }
20825         if (flags & NDR_OUT) {
20826                 if (r->out.job_id == NULL) {
20827                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20828                 }
20829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
20830                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20831         }
20832         return NDR_ERR_SUCCESS;
20833 }
20834
20835 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
20836 {
20837         TALLOC_CTX *_mem_save_handle_0;
20838         TALLOC_CTX *_mem_save_job_id_0;
20839         if (flags & NDR_IN) {
20840                 ZERO_STRUCT(r->out);
20841
20842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20843                         NDR_PULL_ALLOC(ndr, r->in.handle);
20844                 }
20845                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20846                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20847                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20850                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20851                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20852                 NDR_PULL_ALLOC(ndr, r->out.job_id);
20853                 ZERO_STRUCTP(r->out.job_id);
20854         }
20855         if (flags & NDR_OUT) {
20856                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20857                         NDR_PULL_ALLOC(ndr, r->out.job_id);
20858                 }
20859                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
20860                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
20861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
20862                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
20863                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20864         }
20865         return NDR_ERR_SUCCESS;
20866 }
20867
20868 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
20869 {
20870         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
20871         ndr->depth++;
20872         if (flags & NDR_SET_VALUES) {
20873                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20874         }
20875         if (flags & NDR_IN) {
20876                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
20877                 ndr->depth++;
20878                 ndr_print_ptr(ndr, "handle", r->in.handle);
20879                 ndr->depth++;
20880                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20881                 ndr->depth--;
20882                 ndr_print_uint32(ndr, "level", r->in.level);
20883                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20884                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
20885                 ndr->depth--;
20886         }
20887         if (flags & NDR_OUT) {
20888                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
20889                 ndr->depth++;
20890                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
20891                 ndr->depth++;
20892                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
20893                 ndr->depth--;
20894                 ndr_print_WERROR(ndr, "result", r->out.result);
20895                 ndr->depth--;
20896         }
20897         ndr->depth--;
20898 }
20899
20900 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
20901 {
20902         if (flags & NDR_IN) {
20903                 if (r->in.handle == NULL) {
20904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20905                 }
20906                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20907         }
20908         if (flags & NDR_OUT) {
20909                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20910         }
20911         return NDR_ERR_SUCCESS;
20912 }
20913
20914 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
20915 {
20916         TALLOC_CTX *_mem_save_handle_0;
20917         if (flags & NDR_IN) {
20918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20919                         NDR_PULL_ALLOC(ndr, r->in.handle);
20920                 }
20921                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20922                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20923                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20924                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20925         }
20926         if (flags & NDR_OUT) {
20927                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20928         }
20929         return NDR_ERR_SUCCESS;
20930 }
20931
20932 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
20933 {
20934         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
20935         ndr->depth++;
20936         if (flags & NDR_SET_VALUES) {
20937                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20938         }
20939         if (flags & NDR_IN) {
20940                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
20941                 ndr->depth++;
20942                 ndr_print_ptr(ndr, "handle", r->in.handle);
20943                 ndr->depth++;
20944                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20945                 ndr->depth--;
20946                 ndr->depth--;
20947         }
20948         if (flags & NDR_OUT) {
20949                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
20950                 ndr->depth++;
20951                 ndr_print_WERROR(ndr, "result", r->out.result);
20952                 ndr->depth--;
20953         }
20954         ndr->depth--;
20955 }
20956
20957 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
20958 {
20959         if (flags & NDR_IN) {
20960                 if (r->in.handle == NULL) {
20961                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20962                 }
20963                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20964                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
20965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
20966         }
20967         if (flags & NDR_OUT) {
20968                 if (r->out.num_written == 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.num_written));
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_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
20978 {
20979         TALLOC_CTX *_mem_save_handle_0;
20980         TALLOC_CTX *_mem_save_num_written_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_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
20992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
20993                 NDR_PULL_ALLOC(ndr, r->out.num_written);
20994                 ZERO_STRUCTP(r->out.num_written);
20995         }
20996         if (flags & NDR_OUT) {
20997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20998                         NDR_PULL_ALLOC(ndr, r->out.num_written);
20999                 }
21000                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21001                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21005         }
21006         return NDR_ERR_SUCCESS;
21007 }
21008
21009 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21010 {
21011         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21012         ndr->depth++;
21013         if (flags & NDR_SET_VALUES) {
21014                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21015         }
21016         if (flags & NDR_IN) {
21017                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21018                 ndr->depth++;
21019                 ndr_print_ptr(ndr, "handle", r->in.handle);
21020                 ndr->depth++;
21021                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21022                 ndr->depth--;
21023                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21024                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21025                 ndr->depth--;
21026         }
21027         if (flags & NDR_OUT) {
21028                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21029                 ndr->depth++;
21030                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21031                 ndr->depth++;
21032                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21033                 ndr->depth--;
21034                 ndr_print_WERROR(ndr, "result", r->out.result);
21035                 ndr->depth--;
21036         }
21037         ndr->depth--;
21038 }
21039
21040 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21041 {
21042         if (flags & NDR_IN) {
21043                 if (r->in.handle == NULL) {
21044                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21045                 }
21046                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21047         }
21048         if (flags & NDR_OUT) {
21049                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21050         }
21051         return NDR_ERR_SUCCESS;
21052 }
21053
21054 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21055 {
21056         TALLOC_CTX *_mem_save_handle_0;
21057         if (flags & NDR_IN) {
21058                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21059                         NDR_PULL_ALLOC(ndr, r->in.handle);
21060                 }
21061                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21062                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21063                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21064                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21065         }
21066         if (flags & NDR_OUT) {
21067                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21068         }
21069         return NDR_ERR_SUCCESS;
21070 }
21071
21072 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21073 {
21074         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21075         ndr->depth++;
21076         if (flags & NDR_SET_VALUES) {
21077                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21078         }
21079         if (flags & NDR_IN) {
21080                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21081                 ndr->depth++;
21082                 ndr_print_ptr(ndr, "handle", r->in.handle);
21083                 ndr->depth++;
21084                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21085                 ndr->depth--;
21086                 ndr->depth--;
21087         }
21088         if (flags & NDR_OUT) {
21089                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21090                 ndr->depth++;
21091                 ndr_print_WERROR(ndr, "result", r->out.result);
21092                 ndr->depth--;
21093         }
21094         ndr->depth--;
21095 }
21096
21097 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21098 {
21099         if (flags & NDR_IN) {
21100                 if (r->in.handle == NULL) {
21101                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21102                 }
21103                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21104         }
21105         if (flags & NDR_OUT) {
21106                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21107         }
21108         return NDR_ERR_SUCCESS;
21109 }
21110
21111 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21112 {
21113         TALLOC_CTX *_mem_save_handle_0;
21114         if (flags & NDR_IN) {
21115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21116                         NDR_PULL_ALLOC(ndr, r->in.handle);
21117                 }
21118                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21119                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21120                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21121                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21122         }
21123         if (flags & NDR_OUT) {
21124                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21125         }
21126         return NDR_ERR_SUCCESS;
21127 }
21128
21129 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21130 {
21131         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21132         ndr->depth++;
21133         if (flags & NDR_SET_VALUES) {
21134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21135         }
21136         if (flags & NDR_IN) {
21137                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21138                 ndr->depth++;
21139                 ndr_print_ptr(ndr, "handle", r->in.handle);
21140                 ndr->depth++;
21141                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21142                 ndr->depth--;
21143                 ndr->depth--;
21144         }
21145         if (flags & NDR_OUT) {
21146                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21147                 ndr->depth++;
21148                 ndr_print_WERROR(ndr, "result", r->out.result);
21149                 ndr->depth--;
21150         }
21151         ndr->depth--;
21152 }
21153
21154 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21155 {
21156         if (flags & NDR_IN) {
21157                 if (r->in.handle == NULL) {
21158                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21159                 }
21160                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21162         }
21163         if (flags & NDR_OUT) {
21164                 if (r->out.data == NULL) {
21165                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21166                 }
21167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21168                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21169                 if (r->out._data_size == NULL) {
21170                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21171                 }
21172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21173                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21174         }
21175         return NDR_ERR_SUCCESS;
21176 }
21177
21178 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21179 {
21180         TALLOC_CTX *_mem_save_handle_0;
21181         TALLOC_CTX *_mem_save__data_size_0;
21182         if (flags & NDR_IN) {
21183                 ZERO_STRUCT(r->out);
21184
21185                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21186                         NDR_PULL_ALLOC(ndr, r->in.handle);
21187                 }
21188                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21189                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21190                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21191                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21193                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21194                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21195                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21196                 ZERO_STRUCTP(r->out._data_size);
21197         }
21198         if (flags & NDR_OUT) {
21199                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21200                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21201                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21202                 }
21203                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21204                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21205                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21206                 }
21207                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21208                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21212                 if (r->out.data) {
21213                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21214                 }
21215         }
21216         return NDR_ERR_SUCCESS;
21217 }
21218
21219 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21220 {
21221         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21222         ndr->depth++;
21223         if (flags & NDR_SET_VALUES) {
21224                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21225         }
21226         if (flags & NDR_IN) {
21227                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21228                 ndr->depth++;
21229                 ndr_print_ptr(ndr, "handle", r->in.handle);
21230                 ndr->depth++;
21231                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21232                 ndr->depth--;
21233                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21234                 ndr->depth--;
21235         }
21236         if (flags & NDR_OUT) {
21237                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21238                 ndr->depth++;
21239                 ndr_print_ptr(ndr, "data", r->out.data);
21240                 ndr->depth++;
21241                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21242                 ndr->depth--;
21243                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21244                 ndr->depth++;
21245                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21246                 ndr->depth--;
21247                 ndr_print_WERROR(ndr, "result", r->out.result);
21248                 ndr->depth--;
21249         }
21250         ndr->depth--;
21251 }
21252
21253 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21254 {
21255         if (flags & NDR_IN) {
21256                 if (r->in.handle == NULL) {
21257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21258                 }
21259                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21260         }
21261         if (flags & NDR_OUT) {
21262                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21263         }
21264         return NDR_ERR_SUCCESS;
21265 }
21266
21267 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21268 {
21269         TALLOC_CTX *_mem_save_handle_0;
21270         if (flags & NDR_IN) {
21271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21272                         NDR_PULL_ALLOC(ndr, r->in.handle);
21273                 }
21274                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21275                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21276                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21278         }
21279         if (flags & NDR_OUT) {
21280                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21281         }
21282         return NDR_ERR_SUCCESS;
21283 }
21284
21285 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21286 {
21287         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21288         ndr->depth++;
21289         if (flags & NDR_SET_VALUES) {
21290                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21291         }
21292         if (flags & NDR_IN) {
21293                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21294                 ndr->depth++;
21295                 ndr_print_ptr(ndr, "handle", r->in.handle);
21296                 ndr->depth++;
21297                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21298                 ndr->depth--;
21299                 ndr->depth--;
21300         }
21301         if (flags & NDR_OUT) {
21302                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21303                 ndr->depth++;
21304                 ndr_print_WERROR(ndr, "result", r->out.result);
21305                 ndr->depth--;
21306         }
21307         ndr->depth--;
21308 }
21309
21310 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *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, r->in.level));
21318                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21319                 if (r->in.buffer) {
21320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21321                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21322                 }
21323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21324         }
21325         if (flags & NDR_OUT) {
21326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21327                 if (r->out.buffer) {
21328                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21329                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21330                 }
21331                 if (r->out.needed == NULL) {
21332                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21333                 }
21334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21335                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21336         }
21337         return NDR_ERR_SUCCESS;
21338 }
21339
21340 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21341 {
21342         uint32_t _ptr_buffer;
21343         TALLOC_CTX *_mem_save_handle_0;
21344         TALLOC_CTX *_mem_save_buffer_0;
21345         TALLOC_CTX *_mem_save_needed_0;
21346         if (flags & NDR_IN) {
21347                 ZERO_STRUCT(r->out);
21348
21349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21350                         NDR_PULL_ALLOC(ndr, r->in.handle);
21351                 }
21352                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21353                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21354                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21355                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21358                 if (_ptr_buffer) {
21359                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21360                 } else {
21361                         r->in.buffer = NULL;
21362                 }
21363                 if (r->in.buffer) {
21364                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21365                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21367                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21368                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21370                 }
21371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21372                 NDR_PULL_ALLOC(ndr, r->out.needed);
21373                 ZERO_STRUCTP(r->out.needed);
21374                 if (r->in.buffer) {
21375                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21376                 }
21377         }
21378         if (flags & NDR_OUT) {
21379                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21380                 if (_ptr_buffer) {
21381                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21382                 } else {
21383                         r->out.buffer = NULL;
21384                 }
21385                 if (r->out.buffer) {
21386                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21387                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21388                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21389                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21390                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21392                 }
21393                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21394                         NDR_PULL_ALLOC(ndr, r->out.needed);
21395                 }
21396                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21397                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21401                 if (r->out.buffer) {
21402                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21403                 }
21404         }
21405         return NDR_ERR_SUCCESS;
21406 }
21407
21408 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21409 {
21410         ndr_print_struct(ndr, name, "spoolss_AddJob");
21411         ndr->depth++;
21412         if (flags & NDR_SET_VALUES) {
21413                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21414         }
21415         if (flags & NDR_IN) {
21416                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21417                 ndr->depth++;
21418                 ndr_print_ptr(ndr, "handle", r->in.handle);
21419                 ndr->depth++;
21420                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21421                 ndr->depth--;
21422                 ndr_print_uint32(ndr, "level", r->in.level);
21423                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21424                 ndr->depth++;
21425                 if (r->in.buffer) {
21426                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21427                 }
21428                 ndr->depth--;
21429                 ndr_print_uint32(ndr, "offered", r->in.offered);
21430                 ndr->depth--;
21431         }
21432         if (flags & NDR_OUT) {
21433                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21434                 ndr->depth++;
21435                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21436                 ndr->depth++;
21437                 if (r->out.buffer) {
21438                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21439                 }
21440                 ndr->depth--;
21441                 ndr_print_ptr(ndr, "needed", r->out.needed);
21442                 ndr->depth++;
21443                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21444                 ndr->depth--;
21445                 ndr_print_WERROR(ndr, "result", r->out.result);
21446                 ndr->depth--;
21447         }
21448         ndr->depth--;
21449 }
21450
21451 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21452 {
21453         if (flags & NDR_IN) {
21454                 if (r->in.handle == NULL) {
21455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21456                 }
21457                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21459         }
21460         if (flags & NDR_OUT) {
21461                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21462         }
21463         return NDR_ERR_SUCCESS;
21464 }
21465
21466 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21467 {
21468         TALLOC_CTX *_mem_save_handle_0;
21469         if (flags & NDR_IN) {
21470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21471                         NDR_PULL_ALLOC(ndr, r->in.handle);
21472                 }
21473                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21474                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21475                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21478         }
21479         if (flags & NDR_OUT) {
21480                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21481         }
21482         return NDR_ERR_SUCCESS;
21483 }
21484
21485 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21486 {
21487         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21488         ndr->depth++;
21489         if (flags & NDR_SET_VALUES) {
21490                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21491         }
21492         if (flags & NDR_IN) {
21493                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21494                 ndr->depth++;
21495                 ndr_print_ptr(ndr, "handle", r->in.handle);
21496                 ndr->depth++;
21497                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21498                 ndr->depth--;
21499                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21500                 ndr->depth--;
21501         }
21502         if (flags & NDR_OUT) {
21503                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21504                 ndr->depth++;
21505                 ndr_print_WERROR(ndr, "result", r->out.result);
21506                 ndr->depth--;
21507         }
21508         ndr->depth--;
21509 }
21510
21511 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21512 {
21513         if (flags & NDR_IN) {
21514                 if (r->in.handle == NULL) {
21515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21516                 }
21517                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21521                 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));
21522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21523         }
21524         if (flags & NDR_OUT) {
21525                 if (r->out.type == NULL) {
21526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21527                 }
21528                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
21529                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21530                 if (r->out.needed == NULL) {
21531                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21532                 }
21533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21534                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21535         }
21536         return NDR_ERR_SUCCESS;
21537 }
21538
21539 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21540 {
21541         TALLOC_CTX *_mem_save_handle_0;
21542         TALLOC_CTX *_mem_save_type_0;
21543         TALLOC_CTX *_mem_save_needed_0;
21544         if (flags & NDR_IN) {
21545                 ZERO_STRUCT(r->out);
21546
21547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21548                         NDR_PULL_ALLOC(ndr, r->in.handle);
21549                 }
21550                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21551                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21552                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21554                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21555                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21556                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21557                         return 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));
21558                 }
21559                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21560                 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));
21561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21562                 NDR_PULL_ALLOC(ndr, r->out.type);
21563                 ZERO_STRUCTP(r->out.type);
21564                 NDR_PULL_ALLOC(ndr, r->out.needed);
21565                 ZERO_STRUCTP(r->out.needed);
21566         }
21567         if (flags & NDR_OUT) {
21568                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21569                         NDR_PULL_ALLOC(ndr, r->out.type);
21570                 }
21571                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21572                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21573                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
21574                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21575                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
21576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21577                         NDR_PULL_ALLOC(ndr, r->out.needed);
21578                 }
21579                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21580                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21582                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21584         }
21585         return NDR_ERR_SUCCESS;
21586 }
21587
21588 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21589 {
21590         if (flags & NDR_IN) {
21591                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21592         }
21593         if (flags & NDR_OUT) {
21594                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21595                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21596         }
21597         return NDR_ERR_SUCCESS;
21598 }
21599
21600 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21601 {
21602         if (flags & NDR_IN) {
21603                 ZERO_STRUCT(r->out);
21604
21605                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21606         }
21607         if (flags & NDR_OUT) {
21608                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
21609                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21610         }
21611         return NDR_ERR_SUCCESS;
21612 }
21613
21614 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21615 {
21616         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21617         ndr->depth++;
21618         if (flags & NDR_SET_VALUES) {
21619                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21620         }
21621         if (flags & NDR_IN) {
21622                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21623                 ndr->depth++;
21624                 ndr_print_ptr(ndr, "handle", r->in.handle);
21625                 ndr->depth++;
21626                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21627                 ndr->depth--;
21628                 ndr_print_string(ndr, "value_name", r->in.value_name);
21629                 ndr_print_uint32(ndr, "offered", r->in.offered);
21630                 ndr->depth--;
21631         }
21632         if (flags & NDR_OUT) {
21633                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21634                 ndr->depth++;
21635                 ndr_print_ptr(ndr, "type", r->out.type);
21636                 ndr->depth++;
21637                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
21638                 ndr->depth--;
21639                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
21640                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
21641                 ndr_print_ptr(ndr, "needed", r->out.needed);
21642                 ndr->depth++;
21643                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21644                 ndr->depth--;
21645                 ndr_print_WERROR(ndr, "result", r->out.result);
21646                 ndr->depth--;
21647         }
21648         ndr->depth--;
21649 }
21650
21651 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21652 {
21653         if (flags & NDR_IN) {
21654                 if (r->in.handle == NULL) {
21655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21656                 }
21657                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21661                 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));
21662                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21663                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21665         }
21666         if (flags & NDR_OUT) {
21667                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21668         }
21669         return NDR_ERR_SUCCESS;
21670 }
21671
21672 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21673 {
21674         if (flags & NDR_IN) {
21675                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21676         }
21677         if (flags & NDR_OUT) {
21678                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21679                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21680         }
21681         return NDR_ERR_SUCCESS;
21682 }
21683
21684 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21685 {
21686         TALLOC_CTX *_mem_save_handle_0;
21687         if (flags & NDR_IN) {
21688                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21689                         NDR_PULL_ALLOC(ndr, r->in.handle);
21690                 }
21691                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21692                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21693                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21694                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21695                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21696                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21697                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21698                         return 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));
21699                 }
21700                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21701                 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));
21702                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21703                 {
21704                         struct ndr_pull *_ndr_data;
21705                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21706                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21707                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21708                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21709                 }
21710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21711         }
21712         if (flags & NDR_OUT) {
21713                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21714         }
21715         return NDR_ERR_SUCCESS;
21716 }
21717
21718 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21719 {
21720         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21721         ndr->depth++;
21722         if (flags & NDR_SET_VALUES) {
21723                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21724         }
21725         if (flags & NDR_IN) {
21726                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21727                 ndr->depth++;
21728                 ndr_print_ptr(ndr, "handle", r->in.handle);
21729                 ndr->depth++;
21730                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21731                 ndr->depth--;
21732                 ndr_print_string(ndr, "value_name", r->in.value_name);
21733                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
21734                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21735                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21736                 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);
21737                 ndr->depth--;
21738         }
21739         if (flags & NDR_OUT) {
21740                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21741                 ndr->depth++;
21742                 ndr_print_WERROR(ndr, "result", r->out.result);
21743                 ndr->depth--;
21744         }
21745         ndr->depth--;
21746 }
21747
21748 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
21749 {
21750         if (flags & NDR_IN) {
21751         }
21752         if (flags & NDR_OUT) {
21753                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21754         }
21755         return NDR_ERR_SUCCESS;
21756 }
21757
21758 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
21759 {
21760         if (flags & NDR_IN) {
21761         }
21762         if (flags & NDR_OUT) {
21763                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21764         }
21765         return NDR_ERR_SUCCESS;
21766 }
21767
21768 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
21769 {
21770         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
21771         ndr->depth++;
21772         if (flags & NDR_SET_VALUES) {
21773                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21774         }
21775         if (flags & NDR_IN) {
21776                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
21777                 ndr->depth++;
21778                 ndr->depth--;
21779         }
21780         if (flags & NDR_OUT) {
21781                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
21782                 ndr->depth++;
21783                 ndr_print_WERROR(ndr, "result", r->out.result);
21784                 ndr->depth--;
21785         }
21786         ndr->depth--;
21787 }
21788
21789 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
21790 {
21791         if (flags & NDR_IN) {
21792                 if (r->in.handle == NULL) {
21793                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21794                 }
21795                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21796         }
21797         if (flags & NDR_OUT) {
21798                 if (r->out.handle == NULL) {
21799                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21800                 }
21801                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21802                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21803         }
21804         return NDR_ERR_SUCCESS;
21805 }
21806
21807 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
21808 {
21809         TALLOC_CTX *_mem_save_handle_0;
21810         if (flags & NDR_IN) {
21811                 ZERO_STRUCT(r->out);
21812
21813                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21814                         NDR_PULL_ALLOC(ndr, r->in.handle);
21815                 }
21816                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21817                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21818                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21820                 NDR_PULL_ALLOC(ndr, r->out.handle);
21821                 *r->out.handle = *r->in.handle;
21822         }
21823         if (flags & NDR_OUT) {
21824                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21825                         NDR_PULL_ALLOC(ndr, r->out.handle);
21826                 }
21827                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21828                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21829                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21830                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21831                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21832         }
21833         return NDR_ERR_SUCCESS;
21834 }
21835
21836 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
21837 {
21838         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
21839         ndr->depth++;
21840         if (flags & NDR_SET_VALUES) {
21841                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21842         }
21843         if (flags & NDR_IN) {
21844                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
21845                 ndr->depth++;
21846                 ndr_print_ptr(ndr, "handle", r->in.handle);
21847                 ndr->depth++;
21848                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21849                 ndr->depth--;
21850                 ndr->depth--;
21851         }
21852         if (flags & NDR_OUT) {
21853                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
21854                 ndr->depth++;
21855                 ndr_print_ptr(ndr, "handle", r->out.handle);
21856                 ndr->depth++;
21857                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21858                 ndr->depth--;
21859                 ndr_print_WERROR(ndr, "result", r->out.result);
21860                 ndr->depth--;
21861         }
21862         ndr->depth--;
21863 }
21864
21865 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
21866 {
21867         if (flags & NDR_IN) {
21868                 if (r->in.handle == NULL) {
21869                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21870                 }
21871                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21873                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21874                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21875         }
21876         if (flags & NDR_OUT) {
21877                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21878         }
21879         return NDR_ERR_SUCCESS;
21880 }
21881
21882 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
21883 {
21884         TALLOC_CTX *_mem_save_handle_0;
21885         if (flags & NDR_IN) {
21886                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21887                         NDR_PULL_ALLOC(ndr, r->in.handle);
21888                 }
21889                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21890                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21891                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21892                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21894                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21895                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21896         }
21897         if (flags & NDR_OUT) {
21898                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21899         }
21900         return NDR_ERR_SUCCESS;
21901 }
21902
21903 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
21904 {
21905         ndr_print_struct(ndr, name, "spoolss_AddForm");
21906         ndr->depth++;
21907         if (flags & NDR_SET_VALUES) {
21908                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21909         }
21910         if (flags & NDR_IN) {
21911                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
21912                 ndr->depth++;
21913                 ndr_print_ptr(ndr, "handle", r->in.handle);
21914                 ndr->depth++;
21915                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21916                 ndr->depth--;
21917                 ndr_print_uint32(ndr, "level", r->in.level);
21918                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21919                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
21920                 ndr->depth--;
21921         }
21922         if (flags & NDR_OUT) {
21923                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
21924                 ndr->depth++;
21925                 ndr_print_WERROR(ndr, "result", r->out.result);
21926                 ndr->depth--;
21927         }
21928         ndr->depth--;
21929 }
21930
21931 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
21932 {
21933         if (flags & NDR_IN) {
21934                 if (r->in.handle == NULL) {
21935                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21936                 }
21937                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21941                 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));
21942         }
21943         if (flags & NDR_OUT) {
21944                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21945         }
21946         return NDR_ERR_SUCCESS;
21947 }
21948
21949 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
21950 {
21951         TALLOC_CTX *_mem_save_handle_0;
21952         if (flags & NDR_IN) {
21953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21954                         NDR_PULL_ALLOC(ndr, r->in.handle);
21955                 }
21956                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21957                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21958                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21960                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
21961                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
21962                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
21963                         return 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));
21964                 }
21965                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
21966                 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));
21967         }
21968         if (flags & NDR_OUT) {
21969                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21970         }
21971         return NDR_ERR_SUCCESS;
21972 }
21973
21974 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
21975 {
21976         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
21977         ndr->depth++;
21978         if (flags & NDR_SET_VALUES) {
21979                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21980         }
21981         if (flags & NDR_IN) {
21982                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
21983                 ndr->depth++;
21984                 ndr_print_ptr(ndr, "handle", r->in.handle);
21985                 ndr->depth++;
21986                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21987                 ndr->depth--;
21988                 ndr_print_string(ndr, "form_name", r->in.form_name);
21989                 ndr->depth--;
21990         }
21991         if (flags & NDR_OUT) {
21992                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
21993                 ndr->depth++;
21994                 ndr_print_WERROR(ndr, "result", r->out.result);
21995                 ndr->depth--;
21996         }
21997         ndr->depth--;
21998 }
21999
22000 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22001 {
22002         if (flags & NDR_IN) {
22003                 if (r->in.handle == NULL) {
22004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22005                 }
22006                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22010                 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));
22011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22013                 if (r->in.buffer) {
22014                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22015                 }
22016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22017         }
22018         if (flags & NDR_OUT) {
22019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22020                 if (r->out.info) {
22021                         {
22022                                 struct ndr_push *_ndr_info;
22023                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22024                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22025                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22026                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22027                         }
22028                 }
22029                 if (r->out.needed == NULL) {
22030                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22031                 }
22032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22033                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22034         }
22035         return NDR_ERR_SUCCESS;
22036 }
22037
22038 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22039 {
22040         uint32_t _ptr_buffer;
22041         uint32_t _ptr_info;
22042         TALLOC_CTX *_mem_save_handle_0;
22043         TALLOC_CTX *_mem_save_buffer_0;
22044         TALLOC_CTX *_mem_save_info_0;
22045         TALLOC_CTX *_mem_save_needed_0;
22046         if (flags & NDR_IN) {
22047                 ZERO_STRUCT(r->out);
22048
22049                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22050                         NDR_PULL_ALLOC(ndr, r->in.handle);
22051                 }
22052                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22053                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22054                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22055                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22056                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22057                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22058                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22059                         return 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));
22060                 }
22061                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22062                 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));
22063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22065                 if (_ptr_buffer) {
22066                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22067                 } else {
22068                         r->in.buffer = NULL;
22069                 }
22070                 if (r->in.buffer) {
22071                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22072                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22073                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22075                 }
22076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22077                 NDR_PULL_ALLOC(ndr, r->out.needed);
22078                 ZERO_STRUCTP(r->out.needed);
22079         }
22080         if (flags & NDR_OUT) {
22081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22082                 if (_ptr_info) {
22083                         NDR_PULL_ALLOC(ndr, r->out.info);
22084                 } else {
22085                         r->out.info = NULL;
22086                 }
22087                 if (r->out.info) {
22088                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22089                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22090                         {
22091                                 struct ndr_pull *_ndr_info;
22092                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22093                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22094                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22095                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22096                         }
22097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22098                 }
22099                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22100                         NDR_PULL_ALLOC(ndr, r->out.needed);
22101                 }
22102                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22103                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22105                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22106                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22107         }
22108         return NDR_ERR_SUCCESS;
22109 }
22110
22111 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22112 {
22113         ndr_print_struct(ndr, name, "spoolss_GetForm");
22114         ndr->depth++;
22115         if (flags & NDR_SET_VALUES) {
22116                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22117         }
22118         if (flags & NDR_IN) {
22119                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22120                 ndr->depth++;
22121                 ndr_print_ptr(ndr, "handle", r->in.handle);
22122                 ndr->depth++;
22123                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22124                 ndr->depth--;
22125                 ndr_print_string(ndr, "form_name", r->in.form_name);
22126                 ndr_print_uint32(ndr, "level", r->in.level);
22127                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22128                 ndr->depth++;
22129                 if (r->in.buffer) {
22130                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22131                 }
22132                 ndr->depth--;
22133                 ndr_print_uint32(ndr, "offered", r->in.offered);
22134                 ndr->depth--;
22135         }
22136         if (flags & NDR_OUT) {
22137                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22138                 ndr->depth++;
22139                 ndr_print_ptr(ndr, "info", r->out.info);
22140                 ndr->depth++;
22141                 if (r->out.info) {
22142                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22143                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22144                 }
22145                 ndr->depth--;
22146                 ndr_print_ptr(ndr, "needed", r->out.needed);
22147                 ndr->depth++;
22148                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22149                 ndr->depth--;
22150                 ndr_print_WERROR(ndr, "result", r->out.result);
22151                 ndr->depth--;
22152         }
22153         ndr->depth--;
22154 }
22155
22156 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22157 {
22158         if (flags & NDR_IN) {
22159                 if (r->in.handle == NULL) {
22160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22161                 }
22162                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22166                 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));
22167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22168                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22169                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22170         }
22171         if (flags & NDR_OUT) {
22172                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22173         }
22174         return NDR_ERR_SUCCESS;
22175 }
22176
22177 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22178 {
22179         TALLOC_CTX *_mem_save_handle_0;
22180         if (flags & NDR_IN) {
22181                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22182                         NDR_PULL_ALLOC(ndr, r->in.handle);
22183                 }
22184                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22185                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22186                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22187                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22188                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22189                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22190                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22191                         return 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));
22192                 }
22193                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22194                 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));
22195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22196                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22197                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22198         }
22199         if (flags & NDR_OUT) {
22200                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22201         }
22202         return NDR_ERR_SUCCESS;
22203 }
22204
22205 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22206 {
22207         ndr_print_struct(ndr, name, "spoolss_SetForm");
22208         ndr->depth++;
22209         if (flags & NDR_SET_VALUES) {
22210                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22211         }
22212         if (flags & NDR_IN) {
22213                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22214                 ndr->depth++;
22215                 ndr_print_ptr(ndr, "handle", r->in.handle);
22216                 ndr->depth++;
22217                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22218                 ndr->depth--;
22219                 ndr_print_string(ndr, "form_name", r->in.form_name);
22220                 ndr_print_uint32(ndr, "level", r->in.level);
22221                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22222                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22223                 ndr->depth--;
22224         }
22225         if (flags & NDR_OUT) {
22226                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22227                 ndr->depth++;
22228                 ndr_print_WERROR(ndr, "result", r->out.result);
22229                 ndr->depth--;
22230         }
22231         ndr->depth--;
22232 }
22233
22234 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22235 {
22236         if (flags & NDR_IN) {
22237                 if (r->in.handle == NULL) {
22238                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22239                 }
22240                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22242                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22243                 if (r->in.buffer) {
22244                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22245                 }
22246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22247         }
22248         if (flags & NDR_OUT) {
22249                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22250                 if (r->out.info) {
22251                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22252                 }
22253                 if (r->out.needed == NULL) {
22254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22255                 }
22256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22257                 if (r->out.count == NULL) {
22258                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22259                 }
22260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22262         }
22263         return NDR_ERR_SUCCESS;
22264 }
22265
22266 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22267 {
22268         uint32_t _ptr_buffer;
22269         uint32_t _ptr_info;
22270         TALLOC_CTX *_mem_save_handle_0;
22271         TALLOC_CTX *_mem_save_buffer_0;
22272         TALLOC_CTX *_mem_save_info_0;
22273         TALLOC_CTX *_mem_save_needed_0;
22274         TALLOC_CTX *_mem_save_count_0;
22275         if (flags & NDR_IN) {
22276                 ZERO_STRUCT(r->out);
22277
22278                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22279                         NDR_PULL_ALLOC(ndr, r->in.handle);
22280                 }
22281                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22282                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22283                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22284                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22287                 if (_ptr_buffer) {
22288                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22289                 } else {
22290                         r->in.buffer = NULL;
22291                 }
22292                 if (r->in.buffer) {
22293                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22294                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22295                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22297                 }
22298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22299                 NDR_PULL_ALLOC(ndr, r->out.needed);
22300                 ZERO_STRUCTP(r->out.needed);
22301                 NDR_PULL_ALLOC(ndr, r->out.count);
22302                 ZERO_STRUCTP(r->out.count);
22303         }
22304         if (flags & NDR_OUT) {
22305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22306                 if (_ptr_info) {
22307                         NDR_PULL_ALLOC(ndr, r->out.info);
22308                 } else {
22309                         r->out.info = NULL;
22310                 }
22311                 if (r->out.info) {
22312                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22313                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22314                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22316                 }
22317                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22318                         NDR_PULL_ALLOC(ndr, r->out.needed);
22319                 }
22320                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22321                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22325                         NDR_PULL_ALLOC(ndr, r->out.count);
22326                 }
22327                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22328                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22331                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22332         }
22333         return NDR_ERR_SUCCESS;
22334 }
22335
22336 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22337 {
22338         uint32_t cntr_info_0;
22339         if (flags & NDR_IN) {
22340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22342         }
22343         if (flags & NDR_OUT) {
22344                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22345                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22346                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22347                 }
22348                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22349                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22350                 }
22351         }
22352         return NDR_ERR_SUCCESS;
22353 }
22354
22355 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22356 {
22357         uint32_t cntr_info_0;
22358         TALLOC_CTX *_mem_save_info_0;
22359         if (flags & NDR_IN) {
22360                 ZERO_STRUCT(r->out);
22361
22362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22364         }
22365         if (flags & NDR_OUT) {
22366                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22367                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22368                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22369                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22370                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22371                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22372                 }
22373                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22374                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22375                 }
22376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22377         }
22378         return NDR_ERR_SUCCESS;
22379 }
22380
22381 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22382 {
22383         uint32_t cntr_info_2;
22384         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22385         ndr->depth++;
22386         if (flags & NDR_SET_VALUES) {
22387                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22388         }
22389         if (flags & NDR_IN) {
22390                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22391                 ndr->depth++;
22392                 ndr_print_ptr(ndr, "handle", r->in.handle);
22393                 ndr->depth++;
22394                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22395                 ndr->depth--;
22396                 ndr_print_uint32(ndr, "level", r->in.level);
22397                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22398                 ndr->depth++;
22399                 if (r->in.buffer) {
22400                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22401                 }
22402                 ndr->depth--;
22403                 ndr_print_uint32(ndr, "offered", r->in.offered);
22404                 ndr->depth--;
22405         }
22406         if (flags & NDR_OUT) {
22407                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22408                 ndr->depth++;
22409                 ndr_print_ptr(ndr, "count", r->out.count);
22410                 ndr->depth++;
22411                 ndr_print_uint32(ndr, "count", *r->out.count);
22412                 ndr->depth--;
22413                 ndr_print_ptr(ndr, "info", r->out.info);
22414                 ndr->depth++;
22415                 ndr_print_ptr(ndr, "info", *r->out.info);
22416                 ndr->depth++;
22417                 if (*r->out.info) {
22418                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22419                         ndr->depth++;
22420                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22421                                 char *idx_2=NULL;
22422                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22423                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22424                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22425                                         free(idx_2);
22426                                 }
22427                         }
22428                         ndr->depth--;
22429                 }
22430                 ndr->depth--;
22431                 ndr->depth--;
22432                 ndr_print_ptr(ndr, "needed", r->out.needed);
22433                 ndr->depth++;
22434                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22435                 ndr->depth--;
22436                 ndr_print_WERROR(ndr, "result", r->out.result);
22437                 ndr->depth--;
22438         }
22439         ndr->depth--;
22440 }
22441
22442 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22443 {
22444         if (flags & NDR_IN) {
22445                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22446                 if (r->in.servername) {
22447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22450                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22451                 }
22452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22454                 if (r->in.buffer) {
22455                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22456                 }
22457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22458         }
22459         if (flags & NDR_OUT) {
22460                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22461                 if (r->out.info) {
22462                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22463                 }
22464                 if (r->out.needed == NULL) {
22465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22466                 }
22467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22468                 if (r->out.count == NULL) {
22469                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22470                 }
22471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22472                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22473         }
22474         return NDR_ERR_SUCCESS;
22475 }
22476
22477 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22478 {
22479         uint32_t _ptr_servername;
22480         uint32_t _ptr_buffer;
22481         uint32_t _ptr_info;
22482         TALLOC_CTX *_mem_save_servername_0;
22483         TALLOC_CTX *_mem_save_buffer_0;
22484         TALLOC_CTX *_mem_save_info_0;
22485         TALLOC_CTX *_mem_save_needed_0;
22486         TALLOC_CTX *_mem_save_count_0;
22487         if (flags & NDR_IN) {
22488                 ZERO_STRUCT(r->out);
22489
22490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22491                 if (_ptr_servername) {
22492                         NDR_PULL_ALLOC(ndr, r->in.servername);
22493                 } else {
22494                         r->in.servername = NULL;
22495                 }
22496                 if (r->in.servername) {
22497                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22498                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22499                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22500                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22501                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22502                                 return 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));
22503                         }
22504                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22505                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22507                 }
22508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22510                 if (_ptr_buffer) {
22511                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22512                 } else {
22513                         r->in.buffer = NULL;
22514                 }
22515                 if (r->in.buffer) {
22516                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22517                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22518                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22520                 }
22521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22522                 NDR_PULL_ALLOC(ndr, r->out.needed);
22523                 ZERO_STRUCTP(r->out.needed);
22524                 NDR_PULL_ALLOC(ndr, r->out.count);
22525                 ZERO_STRUCTP(r->out.count);
22526         }
22527         if (flags & NDR_OUT) {
22528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22529                 if (_ptr_info) {
22530                         NDR_PULL_ALLOC(ndr, r->out.info);
22531                 } else {
22532                         r->out.info = NULL;
22533                 }
22534                 if (r->out.info) {
22535                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22536                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22537                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22539                 }
22540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22541                         NDR_PULL_ALLOC(ndr, r->out.needed);
22542                 }
22543                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22544                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22548                         NDR_PULL_ALLOC(ndr, r->out.count);
22549                 }
22550                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22551                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22554                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22555         }
22556         return NDR_ERR_SUCCESS;
22557 }
22558
22559 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22560 {
22561         uint32_t cntr_info_0;
22562         if (flags & NDR_IN) {
22563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22565         }
22566         if (flags & NDR_OUT) {
22567                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22568                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22569                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22570                 }
22571                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22572                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22573                 }
22574         }
22575         return NDR_ERR_SUCCESS;
22576 }
22577
22578 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22579 {
22580         uint32_t cntr_info_0;
22581         TALLOC_CTX *_mem_save_info_0;
22582         if (flags & NDR_IN) {
22583                 ZERO_STRUCT(r->out);
22584
22585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22587         }
22588         if (flags & NDR_OUT) {
22589                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22590                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22591                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22592                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22593                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22594                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22595                 }
22596                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22597                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22598                 }
22599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22600         }
22601         return NDR_ERR_SUCCESS;
22602 }
22603
22604 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22605 {
22606         uint32_t cntr_info_2;
22607         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22608         ndr->depth++;
22609         if (flags & NDR_SET_VALUES) {
22610                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22611         }
22612         if (flags & NDR_IN) {
22613                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22614                 ndr->depth++;
22615                 ndr_print_ptr(ndr, "servername", r->in.servername);
22616                 ndr->depth++;
22617                 if (r->in.servername) {
22618                         ndr_print_string(ndr, "servername", r->in.servername);
22619                 }
22620                 ndr->depth--;
22621                 ndr_print_uint32(ndr, "level", r->in.level);
22622                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22623                 ndr->depth++;
22624                 if (r->in.buffer) {
22625                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22626                 }
22627                 ndr->depth--;
22628                 ndr_print_uint32(ndr, "offered", r->in.offered);
22629                 ndr->depth--;
22630         }
22631         if (flags & NDR_OUT) {
22632                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22633                 ndr->depth++;
22634                 ndr_print_ptr(ndr, "count", r->out.count);
22635                 ndr->depth++;
22636                 ndr_print_uint32(ndr, "count", *r->out.count);
22637                 ndr->depth--;
22638                 ndr_print_ptr(ndr, "info", r->out.info);
22639                 ndr->depth++;
22640                 ndr_print_ptr(ndr, "info", *r->out.info);
22641                 ndr->depth++;
22642                 if (*r->out.info) {
22643                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22644                         ndr->depth++;
22645                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22646                                 char *idx_2=NULL;
22647                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22648                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22649                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22650                                         free(idx_2);
22651                                 }
22652                         }
22653                         ndr->depth--;
22654                 }
22655                 ndr->depth--;
22656                 ndr->depth--;
22657                 ndr_print_ptr(ndr, "needed", r->out.needed);
22658                 ndr->depth++;
22659                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22660                 ndr->depth--;
22661                 ndr_print_WERROR(ndr, "result", r->out.result);
22662                 ndr->depth--;
22663         }
22664         ndr->depth--;
22665 }
22666
22667 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22668 {
22669         if (flags & NDR_IN) {
22670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22671                 if (r->in.servername) {
22672                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22675                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22676                 }
22677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22679                 if (r->in.buffer) {
22680                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22681                 }
22682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22683         }
22684         if (flags & NDR_OUT) {
22685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22686                 if (r->out.info) {
22687                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22688                 }
22689                 if (r->out.needed == NULL) {
22690                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22691                 }
22692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22693                 if (r->out.count == NULL) {
22694                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22695                 }
22696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22697                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22698         }
22699         return NDR_ERR_SUCCESS;
22700 }
22701
22702 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22703 {
22704         uint32_t _ptr_servername;
22705         uint32_t _ptr_buffer;
22706         uint32_t _ptr_info;
22707         TALLOC_CTX *_mem_save_servername_0;
22708         TALLOC_CTX *_mem_save_buffer_0;
22709         TALLOC_CTX *_mem_save_info_0;
22710         TALLOC_CTX *_mem_save_needed_0;
22711         TALLOC_CTX *_mem_save_count_0;
22712         if (flags & NDR_IN) {
22713                 ZERO_STRUCT(r->out);
22714
22715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22716                 if (_ptr_servername) {
22717                         NDR_PULL_ALLOC(ndr, r->in.servername);
22718                 } else {
22719                         r->in.servername = NULL;
22720                 }
22721                 if (r->in.servername) {
22722                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22723                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22724                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22725                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22726                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22727                                 return 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));
22728                         }
22729                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22730                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22731                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22732                 }
22733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22735                 if (_ptr_buffer) {
22736                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22737                 } else {
22738                         r->in.buffer = NULL;
22739                 }
22740                 if (r->in.buffer) {
22741                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22742                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22743                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22745                 }
22746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22747                 NDR_PULL_ALLOC(ndr, r->out.needed);
22748                 ZERO_STRUCTP(r->out.needed);
22749                 NDR_PULL_ALLOC(ndr, r->out.count);
22750                 ZERO_STRUCTP(r->out.count);
22751         }
22752         if (flags & NDR_OUT) {
22753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22754                 if (_ptr_info) {
22755                         NDR_PULL_ALLOC(ndr, r->out.info);
22756                 } else {
22757                         r->out.info = NULL;
22758                 }
22759                 if (r->out.info) {
22760                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22761                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22762                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22764                 }
22765                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22766                         NDR_PULL_ALLOC(ndr, r->out.needed);
22767                 }
22768                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22769                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22772                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22773                         NDR_PULL_ALLOC(ndr, r->out.count);
22774                 }
22775                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22776                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22778                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22779                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22780         }
22781         return NDR_ERR_SUCCESS;
22782 }
22783
22784 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
22785 {
22786         uint32_t cntr_info_0;
22787         if (flags & NDR_IN) {
22788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22790         }
22791         if (flags & NDR_OUT) {
22792                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22793                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22794                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22795                 }
22796                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22797                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22798                 }
22799         }
22800         return NDR_ERR_SUCCESS;
22801 }
22802
22803 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
22804 {
22805         uint32_t cntr_info_0;
22806         TALLOC_CTX *_mem_save_info_0;
22807         if (flags & NDR_IN) {
22808                 ZERO_STRUCT(r->out);
22809
22810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22812         }
22813         if (flags & NDR_OUT) {
22814                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22815                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22816                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22817                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22818                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22819                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22820                 }
22821                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22822                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22823                 }
22824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22825         }
22826         return NDR_ERR_SUCCESS;
22827 }
22828
22829 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
22830 {
22831         uint32_t cntr_info_2;
22832         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
22833         ndr->depth++;
22834         if (flags & NDR_SET_VALUES) {
22835                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22836         }
22837         if (flags & NDR_IN) {
22838                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
22839                 ndr->depth++;
22840                 ndr_print_ptr(ndr, "servername", r->in.servername);
22841                 ndr->depth++;
22842                 if (r->in.servername) {
22843                         ndr_print_string(ndr, "servername", r->in.servername);
22844                 }
22845                 ndr->depth--;
22846                 ndr_print_uint32(ndr, "level", r->in.level);
22847                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22848                 ndr->depth++;
22849                 if (r->in.buffer) {
22850                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22851                 }
22852                 ndr->depth--;
22853                 ndr_print_uint32(ndr, "offered", r->in.offered);
22854                 ndr->depth--;
22855         }
22856         if (flags & NDR_OUT) {
22857                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
22858                 ndr->depth++;
22859                 ndr_print_ptr(ndr, "count", r->out.count);
22860                 ndr->depth++;
22861                 ndr_print_uint32(ndr, "count", *r->out.count);
22862                 ndr->depth--;
22863                 ndr_print_ptr(ndr, "info", r->out.info);
22864                 ndr->depth++;
22865                 ndr_print_ptr(ndr, "info", *r->out.info);
22866                 ndr->depth++;
22867                 if (*r->out.info) {
22868                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22869                         ndr->depth++;
22870                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22871                                 char *idx_2=NULL;
22872                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22873                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22874                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22875                                         free(idx_2);
22876                                 }
22877                         }
22878                         ndr->depth--;
22879                 }
22880                 ndr->depth--;
22881                 ndr->depth--;
22882                 ndr_print_ptr(ndr, "needed", r->out.needed);
22883                 ndr->depth++;
22884                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22885                 ndr->depth--;
22886                 ndr_print_WERROR(ndr, "result", r->out.result);
22887                 ndr->depth--;
22888         }
22889         ndr->depth--;
22890 }
22891
22892 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
22893 {
22894         if (flags & NDR_IN) {
22895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
22896                 if (r->in.server_name) {
22897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22900                         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));
22901                 }
22902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
22903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22906                 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));
22907         }
22908         if (flags & NDR_OUT) {
22909                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22910         }
22911         return NDR_ERR_SUCCESS;
22912 }
22913
22914 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
22915 {
22916         uint32_t _ptr_server_name;
22917         TALLOC_CTX *_mem_save_server_name_0;
22918         if (flags & NDR_IN) {
22919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
22920                 if (_ptr_server_name) {
22921                         NDR_PULL_ALLOC(ndr, r->in.server_name);
22922                 } else {
22923                         r->in.server_name = NULL;
22924                 }
22925                 if (r->in.server_name) {
22926                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
22927                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
22928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
22929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
22930                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
22931                                 return 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));
22932                         }
22933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
22934                         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));
22935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
22936                 }
22937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
22938                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
22939                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
22940                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
22941                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.monitor_name), ndr_get_array_length(ndr, &r->in.monitor_name));
22942                 }
22943                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
22944                 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));
22945         }
22946         if (flags & NDR_OUT) {
22947                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22948         }
22949         return NDR_ERR_SUCCESS;
22950 }
22951
22952 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
22953 {
22954         ndr_print_struct(ndr, name, "spoolss_AddPort");
22955         ndr->depth++;
22956         if (flags & NDR_SET_VALUES) {
22957                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22958         }
22959         if (flags & NDR_IN) {
22960                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
22961                 ndr->depth++;
22962                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
22963                 ndr->depth++;
22964                 if (r->in.server_name) {
22965                         ndr_print_string(ndr, "server_name", r->in.server_name);
22966                 }
22967                 ndr->depth--;
22968                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
22969                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
22970                 ndr->depth--;
22971         }
22972         if (flags & NDR_OUT) {
22973                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
22974                 ndr->depth++;
22975                 ndr_print_WERROR(ndr, "result", r->out.result);
22976                 ndr->depth--;
22977         }
22978         ndr->depth--;
22979 }
22980
22981 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
22982 {
22983         if (flags & NDR_IN) {
22984         }
22985         if (flags & NDR_OUT) {
22986                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22987         }
22988         return NDR_ERR_SUCCESS;
22989 }
22990
22991 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
22992 {
22993         if (flags & NDR_IN) {
22994         }
22995         if (flags & NDR_OUT) {
22996                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22997         }
22998         return NDR_ERR_SUCCESS;
22999 }
23000
23001 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23002 {
23003         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23004         ndr->depth++;
23005         if (flags & NDR_SET_VALUES) {
23006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23007         }
23008         if (flags & NDR_IN) {
23009                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23010                 ndr->depth++;
23011                 ndr->depth--;
23012         }
23013         if (flags & NDR_OUT) {
23014                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23015                 ndr->depth++;
23016                 ndr_print_WERROR(ndr, "result", r->out.result);
23017                 ndr->depth--;
23018         }
23019         ndr->depth--;
23020 }
23021
23022 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23023 {
23024         if (flags & NDR_IN) {
23025         }
23026         if (flags & NDR_OUT) {
23027                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23028         }
23029         return NDR_ERR_SUCCESS;
23030 }
23031
23032 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23033 {
23034         if (flags & NDR_IN) {
23035         }
23036         if (flags & NDR_OUT) {
23037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23038         }
23039         return NDR_ERR_SUCCESS;
23040 }
23041
23042 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23043 {
23044         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23045         ndr->depth++;
23046         if (flags & NDR_SET_VALUES) {
23047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23048         }
23049         if (flags & NDR_IN) {
23050                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23051                 ndr->depth++;
23052                 ndr->depth--;
23053         }
23054         if (flags & NDR_OUT) {
23055                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23056                 ndr->depth++;
23057                 ndr_print_WERROR(ndr, "result", r->out.result);
23058                 ndr->depth--;
23059         }
23060         ndr->depth--;
23061 }
23062
23063 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23064 {
23065         if (flags & NDR_IN) {
23066         }
23067         if (flags & NDR_OUT) {
23068                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23069         }
23070         return NDR_ERR_SUCCESS;
23071 }
23072
23073 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23074 {
23075         if (flags & NDR_IN) {
23076         }
23077         if (flags & NDR_OUT) {
23078                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23079         }
23080         return NDR_ERR_SUCCESS;
23081 }
23082
23083 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23084 {
23085         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23086         ndr->depth++;
23087         if (flags & NDR_SET_VALUES) {
23088                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23089         }
23090         if (flags & NDR_IN) {
23091                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23092                 ndr->depth++;
23093                 ndr->depth--;
23094         }
23095         if (flags & NDR_OUT) {
23096                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23097                 ndr->depth++;
23098                 ndr_print_WERROR(ndr, "result", r->out.result);
23099                 ndr->depth--;
23100         }
23101         ndr->depth--;
23102 }
23103
23104 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23105 {
23106         if (flags & NDR_IN) {
23107         }
23108         if (flags & NDR_OUT) {
23109                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23110         }
23111         return NDR_ERR_SUCCESS;
23112 }
23113
23114 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23115 {
23116         if (flags & NDR_IN) {
23117         }
23118         if (flags & NDR_OUT) {
23119                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23120         }
23121         return NDR_ERR_SUCCESS;
23122 }
23123
23124 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23125 {
23126         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23127         ndr->depth++;
23128         if (flags & NDR_SET_VALUES) {
23129                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23130         }
23131         if (flags & NDR_IN) {
23132                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23133                 ndr->depth++;
23134                 ndr->depth--;
23135         }
23136         if (flags & NDR_OUT) {
23137                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23138                 ndr->depth++;
23139                 ndr_print_WERROR(ndr, "result", r->out.result);
23140                 ndr->depth--;
23141         }
23142         ndr->depth--;
23143 }
23144
23145 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23146 {
23147         if (flags & NDR_IN) {
23148         }
23149         if (flags & NDR_OUT) {
23150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23151         }
23152         return NDR_ERR_SUCCESS;
23153 }
23154
23155 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23156 {
23157         if (flags & NDR_IN) {
23158         }
23159         if (flags & NDR_OUT) {
23160                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23161         }
23162         return NDR_ERR_SUCCESS;
23163 }
23164
23165 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23166 {
23167         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23168         ndr->depth++;
23169         if (flags & NDR_SET_VALUES) {
23170                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23171         }
23172         if (flags & NDR_IN) {
23173                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23174                 ndr->depth++;
23175                 ndr->depth--;
23176         }
23177         if (flags & NDR_OUT) {
23178                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23179                 ndr->depth++;
23180                 ndr_print_WERROR(ndr, "result", r->out.result);
23181                 ndr->depth--;
23182         }
23183         ndr->depth--;
23184 }
23185
23186 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23187 {
23188         if (flags & NDR_IN) {
23189         }
23190         if (flags & NDR_OUT) {
23191                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23192         }
23193         return NDR_ERR_SUCCESS;
23194 }
23195
23196 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23197 {
23198         if (flags & NDR_IN) {
23199         }
23200         if (flags & NDR_OUT) {
23201                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23202         }
23203         return NDR_ERR_SUCCESS;
23204 }
23205
23206 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23207 {
23208         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23209         ndr->depth++;
23210         if (flags & NDR_SET_VALUES) {
23211                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23212         }
23213         if (flags & NDR_IN) {
23214                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23215                 ndr->depth++;
23216                 ndr->depth--;
23217         }
23218         if (flags & NDR_OUT) {
23219                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23220                 ndr->depth++;
23221                 ndr_print_WERROR(ndr, "result", r->out.result);
23222                 ndr->depth--;
23223         }
23224         ndr->depth--;
23225 }
23226
23227 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23228 {
23229         if (flags & NDR_IN) {
23230         }
23231         if (flags & NDR_OUT) {
23232                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23233         }
23234         return NDR_ERR_SUCCESS;
23235 }
23236
23237 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23238 {
23239         if (flags & NDR_IN) {
23240         }
23241         if (flags & NDR_OUT) {
23242                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23243         }
23244         return NDR_ERR_SUCCESS;
23245 }
23246
23247 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23248 {
23249         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23250         ndr->depth++;
23251         if (flags & NDR_SET_VALUES) {
23252                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23253         }
23254         if (flags & NDR_IN) {
23255                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23256                 ndr->depth++;
23257                 ndr->depth--;
23258         }
23259         if (flags & NDR_OUT) {
23260                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23261                 ndr->depth++;
23262                 ndr_print_WERROR(ndr, "result", r->out.result);
23263                 ndr->depth--;
23264         }
23265         ndr->depth--;
23266 }
23267
23268 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23269 {
23270         if (flags & NDR_IN) {
23271         }
23272         if (flags & NDR_OUT) {
23273                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23274         }
23275         return NDR_ERR_SUCCESS;
23276 }
23277
23278 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23279 {
23280         if (flags & NDR_IN) {
23281         }
23282         if (flags & NDR_OUT) {
23283                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23284         }
23285         return NDR_ERR_SUCCESS;
23286 }
23287
23288 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23289 {
23290         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23291         ndr->depth++;
23292         if (flags & NDR_SET_VALUES) {
23293                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23294         }
23295         if (flags & NDR_IN) {
23296                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23297                 ndr->depth++;
23298                 ndr->depth--;
23299         }
23300         if (flags & NDR_OUT) {
23301                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23302                 ndr->depth++;
23303                 ndr_print_WERROR(ndr, "result", r->out.result);
23304                 ndr->depth--;
23305         }
23306         ndr->depth--;
23307 }
23308
23309 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23310 {
23311         if (flags & NDR_IN) {
23312         }
23313         if (flags & NDR_OUT) {
23314                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23315         }
23316         return NDR_ERR_SUCCESS;
23317 }
23318
23319 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23320 {
23321         if (flags & NDR_IN) {
23322         }
23323         if (flags & NDR_OUT) {
23324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23325         }
23326         return NDR_ERR_SUCCESS;
23327 }
23328
23329 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23330 {
23331         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23332         ndr->depth++;
23333         if (flags & NDR_SET_VALUES) {
23334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23335         }
23336         if (flags & NDR_IN) {
23337                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23338                 ndr->depth++;
23339                 ndr->depth--;
23340         }
23341         if (flags & NDR_OUT) {
23342                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23343                 ndr->depth++;
23344                 ndr_print_WERROR(ndr, "result", r->out.result);
23345                 ndr->depth--;
23346         }
23347         ndr->depth--;
23348 }
23349
23350 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23351 {
23352         if (flags & NDR_IN) {
23353         }
23354         if (flags & NDR_OUT) {
23355                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23356         }
23357         return NDR_ERR_SUCCESS;
23358 }
23359
23360 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23361 {
23362         if (flags & NDR_IN) {
23363         }
23364         if (flags & NDR_OUT) {
23365                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23366         }
23367         return NDR_ERR_SUCCESS;
23368 }
23369
23370 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23371 {
23372         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23373         ndr->depth++;
23374         if (flags & NDR_SET_VALUES) {
23375                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23376         }
23377         if (flags & NDR_IN) {
23378                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23379                 ndr->depth++;
23380                 ndr->depth--;
23381         }
23382         if (flags & NDR_OUT) {
23383                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23384                 ndr->depth++;
23385                 ndr_print_WERROR(ndr, "result", r->out.result);
23386                 ndr->depth--;
23387         }
23388         ndr->depth--;
23389 }
23390
23391 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23392 {
23393         if (flags & NDR_IN) {
23394         }
23395         if (flags & NDR_OUT) {
23396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23397         }
23398         return NDR_ERR_SUCCESS;
23399 }
23400
23401 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23402 {
23403         if (flags & NDR_IN) {
23404         }
23405         if (flags & NDR_OUT) {
23406                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23407         }
23408         return NDR_ERR_SUCCESS;
23409 }
23410
23411 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23412 {
23413         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23414         ndr->depth++;
23415         if (flags & NDR_SET_VALUES) {
23416                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23417         }
23418         if (flags & NDR_IN) {
23419                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23420                 ndr->depth++;
23421                 ndr->depth--;
23422         }
23423         if (flags & NDR_OUT) {
23424                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23425                 ndr->depth++;
23426                 ndr_print_WERROR(ndr, "result", r->out.result);
23427                 ndr->depth--;
23428         }
23429         ndr->depth--;
23430 }
23431
23432 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23433 {
23434         if (flags & NDR_IN) {
23435         }
23436         if (flags & NDR_OUT) {
23437                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23438         }
23439         return NDR_ERR_SUCCESS;
23440 }
23441
23442 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23443 {
23444         if (flags & NDR_IN) {
23445         }
23446         if (flags & NDR_OUT) {
23447                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23448         }
23449         return NDR_ERR_SUCCESS;
23450 }
23451
23452 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23453 {
23454         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23455         ndr->depth++;
23456         if (flags & NDR_SET_VALUES) {
23457                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23458         }
23459         if (flags & NDR_IN) {
23460                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23461                 ndr->depth++;
23462                 ndr->depth--;
23463         }
23464         if (flags & NDR_OUT) {
23465                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23466                 ndr->depth++;
23467                 ndr_print_WERROR(ndr, "result", r->out.result);
23468                 ndr->depth--;
23469         }
23470         ndr->depth--;
23471 }
23472
23473 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23474 {
23475         if (flags & NDR_IN) {
23476         }
23477         if (flags & NDR_OUT) {
23478                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23479         }
23480         return NDR_ERR_SUCCESS;
23481 }
23482
23483 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23484 {
23485         if (flags & NDR_IN) {
23486         }
23487         if (flags & NDR_OUT) {
23488                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23489         }
23490         return NDR_ERR_SUCCESS;
23491 }
23492
23493 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23494 {
23495         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23496         ndr->depth++;
23497         if (flags & NDR_SET_VALUES) {
23498                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23499         }
23500         if (flags & NDR_IN) {
23501                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23502                 ndr->depth++;
23503                 ndr->depth--;
23504         }
23505         if (flags & NDR_OUT) {
23506                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23507                 ndr->depth++;
23508                 ndr_print_WERROR(ndr, "result", r->out.result);
23509                 ndr->depth--;
23510         }
23511         ndr->depth--;
23512 }
23513
23514 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23515 {
23516         if (flags & NDR_IN) {
23517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23518                 if (r->in.servername) {
23519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23521                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23522                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23523                 }
23524                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23525                 if (r->in.print_processor_name) {
23526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23528                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23529                         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));
23530                 }
23531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23532                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23533                 if (r->in.buffer) {
23534                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23535                 }
23536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23537         }
23538         if (flags & NDR_OUT) {
23539                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23540                 if (r->out.info) {
23541                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23542                 }
23543                 if (r->out.needed == NULL) {
23544                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23545                 }
23546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23547                 if (r->out.count == NULL) {
23548                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23549                 }
23550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23551                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23552         }
23553         return NDR_ERR_SUCCESS;
23554 }
23555
23556 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23557 {
23558         uint32_t _ptr_servername;
23559         uint32_t _ptr_print_processor_name;
23560         uint32_t _ptr_buffer;
23561         uint32_t _ptr_info;
23562         TALLOC_CTX *_mem_save_servername_0;
23563         TALLOC_CTX *_mem_save_print_processor_name_0;
23564         TALLOC_CTX *_mem_save_buffer_0;
23565         TALLOC_CTX *_mem_save_info_0;
23566         TALLOC_CTX *_mem_save_needed_0;
23567         TALLOC_CTX *_mem_save_count_0;
23568         if (flags & NDR_IN) {
23569                 ZERO_STRUCT(r->out);
23570
23571                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23572                 if (_ptr_servername) {
23573                         NDR_PULL_ALLOC(ndr, r->in.servername);
23574                 } else {
23575                         r->in.servername = NULL;
23576                 }
23577                 if (r->in.servername) {
23578                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23579                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23580                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23581                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23582                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23583                                 return 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));
23584                         }
23585                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23586                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23587                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23588                 }
23589                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23590                 if (_ptr_print_processor_name) {
23591                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23592                 } else {
23593                         r->in.print_processor_name = NULL;
23594                 }
23595                 if (r->in.print_processor_name) {
23596                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23597                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23598                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23599                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23600                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23601                                 return 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));
23602                         }
23603                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23604                         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));
23605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23606                 }
23607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23608                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23609                 if (_ptr_buffer) {
23610                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23611                 } else {
23612                         r->in.buffer = NULL;
23613                 }
23614                 if (r->in.buffer) {
23615                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23616                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23617                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23618                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23619                 }
23620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23621                 NDR_PULL_ALLOC(ndr, r->out.needed);
23622                 ZERO_STRUCTP(r->out.needed);
23623                 NDR_PULL_ALLOC(ndr, r->out.count);
23624                 ZERO_STRUCTP(r->out.count);
23625         }
23626         if (flags & NDR_OUT) {
23627                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23628                 if (_ptr_info) {
23629                         NDR_PULL_ALLOC(ndr, r->out.info);
23630                 } else {
23631                         r->out.info = NULL;
23632                 }
23633                 if (r->out.info) {
23634                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23635                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23636                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23638                 }
23639                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23640                         NDR_PULL_ALLOC(ndr, r->out.needed);
23641                 }
23642                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23643                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23645                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23647                         NDR_PULL_ALLOC(ndr, r->out.count);
23648                 }
23649                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23650                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23653                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23654         }
23655         return NDR_ERR_SUCCESS;
23656 }
23657
23658 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
23659 {
23660         uint32_t cntr_info_0;
23661         if (flags & NDR_IN) {
23662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23664         }
23665         if (flags & NDR_OUT) {
23666                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23667                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23668                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23669                 }
23670                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23671                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23672                 }
23673         }
23674         return NDR_ERR_SUCCESS;
23675 }
23676
23677 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
23678 {
23679         uint32_t cntr_info_0;
23680         TALLOC_CTX *_mem_save_info_0;
23681         if (flags & NDR_IN) {
23682                 ZERO_STRUCT(r->out);
23683
23684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23686         }
23687         if (flags & NDR_OUT) {
23688                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23689                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23690                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23691                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23692                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23693                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23694                 }
23695                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23696                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23697                 }
23698                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23699         }
23700         return NDR_ERR_SUCCESS;
23701 }
23702
23703 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23704 {
23705         uint32_t cntr_info_2;
23706         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23707         ndr->depth++;
23708         if (flags & NDR_SET_VALUES) {
23709                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23710         }
23711         if (flags & NDR_IN) {
23712                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23713                 ndr->depth++;
23714                 ndr_print_ptr(ndr, "servername", r->in.servername);
23715                 ndr->depth++;
23716                 if (r->in.servername) {
23717                         ndr_print_string(ndr, "servername", r->in.servername);
23718                 }
23719                 ndr->depth--;
23720                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
23721                 ndr->depth++;
23722                 if (r->in.print_processor_name) {
23723                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23724                 }
23725                 ndr->depth--;
23726                 ndr_print_uint32(ndr, "level", r->in.level);
23727                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23728                 ndr->depth++;
23729                 if (r->in.buffer) {
23730                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23731                 }
23732                 ndr->depth--;
23733                 ndr_print_uint32(ndr, "offered", r->in.offered);
23734                 ndr->depth--;
23735         }
23736         if (flags & NDR_OUT) {
23737                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23738                 ndr->depth++;
23739                 ndr_print_ptr(ndr, "count", r->out.count);
23740                 ndr->depth++;
23741                 ndr_print_uint32(ndr, "count", *r->out.count);
23742                 ndr->depth--;
23743                 ndr_print_ptr(ndr, "info", r->out.info);
23744                 ndr->depth++;
23745                 ndr_print_ptr(ndr, "info", *r->out.info);
23746                 ndr->depth++;
23747                 if (*r->out.info) {
23748                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23749                         ndr->depth++;
23750                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23751                                 char *idx_2=NULL;
23752                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23753                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23754                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23755                                         free(idx_2);
23756                                 }
23757                         }
23758                         ndr->depth--;
23759                 }
23760                 ndr->depth--;
23761                 ndr->depth--;
23762                 ndr_print_ptr(ndr, "needed", r->out.needed);
23763                 ndr->depth++;
23764                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23765                 ndr->depth--;
23766                 ndr_print_WERROR(ndr, "result", r->out.result);
23767                 ndr->depth--;
23768         }
23769         ndr->depth--;
23770 }
23771
23772 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
23773 {
23774         if (flags & NDR_IN) {
23775                 if (r->in.handle == NULL) {
23776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23777                 }
23778                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
23780                 if (r->in.data_type) {
23781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23784                         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));
23785                 }
23786                 if (r->in.devmode_ctr == NULL) {
23787                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23788                 }
23789                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23790         }
23791         if (flags & NDR_OUT) {
23792                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23793         }
23794         return NDR_ERR_SUCCESS;
23795 }
23796
23797 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
23798 {
23799         uint32_t _ptr_data_type;
23800         TALLOC_CTX *_mem_save_handle_0;
23801         TALLOC_CTX *_mem_save_data_type_0;
23802         TALLOC_CTX *_mem_save_devmode_ctr_0;
23803         if (flags & NDR_IN) {
23804                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23805                         NDR_PULL_ALLOC(ndr, r->in.handle);
23806                 }
23807                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23808                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23809                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23810                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23811                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
23812                 if (_ptr_data_type) {
23813                         NDR_PULL_ALLOC(ndr, r->in.data_type);
23814                 } else {
23815                         r->in.data_type = NULL;
23816                 }
23817                 if (r->in.data_type) {
23818                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23819                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
23820                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
23821                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
23822                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
23823                                 return 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));
23824                         }
23825                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
23826                         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));
23827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
23828                 }
23829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23830                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23831                 }
23832                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23833                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23834                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23836         }
23837         if (flags & NDR_OUT) {
23838                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23839         }
23840         return NDR_ERR_SUCCESS;
23841 }
23842
23843 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
23844 {
23845         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
23846         ndr->depth++;
23847         if (flags & NDR_SET_VALUES) {
23848                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23849         }
23850         if (flags & NDR_IN) {
23851                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
23852                 ndr->depth++;
23853                 ndr_print_ptr(ndr, "handle", r->in.handle);
23854                 ndr->depth++;
23855                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23856                 ndr->depth--;
23857                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
23858                 ndr->depth++;
23859                 if (r->in.data_type) {
23860                         ndr_print_string(ndr, "data_type", r->in.data_type);
23861                 }
23862                 ndr->depth--;
23863                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23864                 ndr->depth++;
23865                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23866                 ndr->depth--;
23867                 ndr->depth--;
23868         }
23869         if (flags & NDR_OUT) {
23870                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
23871                 ndr->depth++;
23872                 ndr_print_WERROR(ndr, "result", r->out.result);
23873                 ndr->depth--;
23874         }
23875         ndr->depth--;
23876 }
23877
23878 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
23879 {
23880         if (flags & NDR_IN) {
23881                 if (r->in.handle == NULL) {
23882                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23883                 }
23884                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
23886                 if (r->in.architecture) {
23887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23890                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23891                 }
23892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23894                 if (r->in.buffer) {
23895                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23896                 }
23897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
23899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
23900         }
23901         if (flags & NDR_OUT) {
23902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23903                 if (r->out.info) {
23904                         {
23905                                 struct ndr_push *_ndr_info;
23906                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23907                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23908                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23909                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23910                         }
23911                 }
23912                 if (r->out.needed == NULL) {
23913                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23914                 }
23915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23916                 if (r->out.server_major_version == NULL) {
23917                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23918                 }
23919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
23920                 if (r->out.server_minor_version == NULL) {
23921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23922                 }
23923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
23924                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23925         }
23926         return NDR_ERR_SUCCESS;
23927 }
23928
23929 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
23930 {
23931         uint32_t _ptr_architecture;
23932         uint32_t _ptr_buffer;
23933         uint32_t _ptr_info;
23934         TALLOC_CTX *_mem_save_handle_0;
23935         TALLOC_CTX *_mem_save_architecture_0;
23936         TALLOC_CTX *_mem_save_buffer_0;
23937         TALLOC_CTX *_mem_save_info_0;
23938         TALLOC_CTX *_mem_save_needed_0;
23939         TALLOC_CTX *_mem_save_server_major_version_0;
23940         TALLOC_CTX *_mem_save_server_minor_version_0;
23941         if (flags & NDR_IN) {
23942                 ZERO_STRUCT(r->out);
23943
23944                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23945                         NDR_PULL_ALLOC(ndr, r->in.handle);
23946                 }
23947                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23948                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23949                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23950                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23951                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
23952                 if (_ptr_architecture) {
23953                         NDR_PULL_ALLOC(ndr, r->in.architecture);
23954                 } else {
23955                         r->in.architecture = NULL;
23956                 }
23957                 if (r->in.architecture) {
23958                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
23959                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
23960                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
23961                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
23962                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
23963                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
23964                         }
23965                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
23966                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
23967                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
23968                 }
23969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23971                 if (_ptr_buffer) {
23972                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23973                 } else {
23974                         r->in.buffer = NULL;
23975                 }
23976                 if (r->in.buffer) {
23977                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23978                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23979                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23981                 }
23982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
23984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
23985                 NDR_PULL_ALLOC(ndr, r->out.needed);
23986                 ZERO_STRUCTP(r->out.needed);
23987                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
23988                 ZERO_STRUCTP(r->out.server_major_version);
23989                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
23990                 ZERO_STRUCTP(r->out.server_minor_version);
23991         }
23992         if (flags & NDR_OUT) {
23993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23994                 if (_ptr_info) {
23995                         NDR_PULL_ALLOC(ndr, r->out.info);
23996                 } else {
23997                         r->out.info = NULL;
23998                 }
23999                 if (r->out.info) {
24000                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24001                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24002                         {
24003                                 struct ndr_pull *_ndr_info;
24004                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24005                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24006                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24007                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24008                         }
24009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24010                 }
24011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24012                         NDR_PULL_ALLOC(ndr, r->out.needed);
24013                 }
24014                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24015                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24019                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24020                 }
24021                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24022                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24026                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24027                 }
24028                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24029                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
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_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24038 {
24039         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
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_GetPrinterDriver2");
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_ptr(ndr, "architecture", r->in.architecture);
24052                 ndr->depth++;
24053                 if (r->in.architecture) {
24054                         ndr_print_string(ndr, "architecture", r->in.architecture);
24055                 }
24056                 ndr->depth--;
24057                 ndr_print_uint32(ndr, "level", r->in.level);
24058                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24059                 ndr->depth++;
24060                 if (r->in.buffer) {
24061                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24062                 }
24063                 ndr->depth--;
24064                 ndr_print_uint32(ndr, "offered", r->in.offered);
24065                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24066                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24067                 ndr->depth--;
24068         }
24069         if (flags & NDR_OUT) {
24070                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24071                 ndr->depth++;
24072                 ndr_print_ptr(ndr, "info", r->out.info);
24073                 ndr->depth++;
24074                 if (r->out.info) {
24075                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24076                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24077                 }
24078                 ndr->depth--;
24079                 ndr_print_ptr(ndr, "needed", r->out.needed);
24080                 ndr->depth++;
24081                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24082                 ndr->depth--;
24083                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24084                 ndr->depth++;
24085                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24086                 ndr->depth--;
24087                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24088                 ndr->depth++;
24089                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24090                 ndr->depth--;
24091                 ndr_print_WERROR(ndr, "result", r->out.result);
24092                 ndr->depth--;
24093         }
24094         ndr->depth--;
24095 }
24096
24097 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24098 {
24099         if (flags & NDR_IN) {
24100         }
24101         if (flags & NDR_OUT) {
24102                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24103         }
24104         return NDR_ERR_SUCCESS;
24105 }
24106
24107 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24108 {
24109         if (flags & NDR_IN) {
24110         }
24111         if (flags & NDR_OUT) {
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_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24118 {
24119         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
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_FindFirstPrinterChangeNotification");
24126                 ndr->depth++;
24127                 ndr->depth--;
24128         }
24129         if (flags & NDR_OUT) {
24130                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24131                 ndr->depth++;
24132                 ndr_print_WERROR(ndr, "result", r->out.result);
24133                 ndr->depth--;
24134         }
24135         ndr->depth--;
24136 }
24137
24138 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24139 {
24140         if (flags & NDR_IN) {
24141         }
24142         if (flags & NDR_OUT) {
24143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24144         }
24145         return NDR_ERR_SUCCESS;
24146 }
24147
24148 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24149 {
24150         if (flags & NDR_IN) {
24151         }
24152         if (flags & NDR_OUT) {
24153                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24154         }
24155         return NDR_ERR_SUCCESS;
24156 }
24157
24158 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24159 {
24160         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24161         ndr->depth++;
24162         if (flags & NDR_SET_VALUES) {
24163                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24164         }
24165         if (flags & NDR_IN) {
24166                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24167                 ndr->depth++;
24168                 ndr->depth--;
24169         }
24170         if (flags & NDR_OUT) {
24171                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24172                 ndr->depth++;
24173                 ndr_print_WERROR(ndr, "result", r->out.result);
24174                 ndr->depth--;
24175         }
24176         ndr->depth--;
24177 }
24178
24179 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24180 {
24181         if (flags & NDR_IN) {
24182                 if (r->in.handle == NULL) {
24183                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24184                 }
24185                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24186         }
24187         if (flags & NDR_OUT) {
24188                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24189         }
24190         return NDR_ERR_SUCCESS;
24191 }
24192
24193 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24194 {
24195         TALLOC_CTX *_mem_save_handle_0;
24196         if (flags & NDR_IN) {
24197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24198                         NDR_PULL_ALLOC(ndr, r->in.handle);
24199                 }
24200                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24201                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24202                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24204         }
24205         if (flags & NDR_OUT) {
24206                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24207         }
24208         return NDR_ERR_SUCCESS;
24209 }
24210
24211 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24212 {
24213         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24214         ndr->depth++;
24215         if (flags & NDR_SET_VALUES) {
24216                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24217         }
24218         if (flags & NDR_IN) {
24219                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24220                 ndr->depth++;
24221                 ndr_print_ptr(ndr, "handle", r->in.handle);
24222                 ndr->depth++;
24223                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24224                 ndr->depth--;
24225                 ndr->depth--;
24226         }
24227         if (flags & NDR_OUT) {
24228                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24229                 ndr->depth++;
24230                 ndr_print_WERROR(ndr, "result", r->out.result);
24231                 ndr->depth--;
24232         }
24233         ndr->depth--;
24234 }
24235
24236 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24237 {
24238         if (flags & NDR_IN) {
24239         }
24240         if (flags & NDR_OUT) {
24241                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24242         }
24243         return NDR_ERR_SUCCESS;
24244 }
24245
24246 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24247 {
24248         if (flags & NDR_IN) {
24249         }
24250         if (flags & NDR_OUT) {
24251                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24252         }
24253         return NDR_ERR_SUCCESS;
24254 }
24255
24256 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24257 {
24258         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24259         ndr->depth++;
24260         if (flags & NDR_SET_VALUES) {
24261                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24262         }
24263         if (flags & NDR_IN) {
24264                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24265                 ndr->depth++;
24266                 ndr->depth--;
24267         }
24268         if (flags & NDR_OUT) {
24269                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24270                 ndr->depth++;
24271                 ndr_print_WERROR(ndr, "result", r->out.result);
24272                 ndr->depth--;
24273         }
24274         ndr->depth--;
24275 }
24276
24277 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24278 {
24279         if (flags & NDR_IN) {
24280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24283                 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));
24284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24285                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24287                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24288                 if (r->in.buffer) {
24289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24290                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24291                 }
24292         }
24293         if (flags & NDR_OUT) {
24294                 if (r->out.handle == NULL) {
24295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24296                 }
24297                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24298                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24299         }
24300         return NDR_ERR_SUCCESS;
24301 }
24302
24303 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24304 {
24305         uint32_t _ptr_buffer;
24306         TALLOC_CTX *_mem_save_buffer_0;
24307         TALLOC_CTX *_mem_save_handle_0;
24308         if (flags & NDR_IN) {
24309                 ZERO_STRUCT(r->out);
24310
24311                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24312                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24313                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24314                         return 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));
24315                 }
24316                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24317                 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));
24318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24319                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24321                 if (r->in.bufsize > 512) {
24322                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24323                 }
24324                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24325                 if (_ptr_buffer) {
24326                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24327                 } else {
24328                         r->in.buffer = NULL;
24329                 }
24330                 if (r->in.buffer) {
24331                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24332                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24334                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24335                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24337                 }
24338                 NDR_PULL_ALLOC(ndr, r->out.handle);
24339                 ZERO_STRUCTP(r->out.handle);
24340                 if (r->in.buffer) {
24341                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24342                 }
24343         }
24344         if (flags & NDR_OUT) {
24345                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24346                         NDR_PULL_ALLOC(ndr, r->out.handle);
24347                 }
24348                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24349                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24350                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24352                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24353         }
24354         return NDR_ERR_SUCCESS;
24355 }
24356
24357 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24358 {
24359         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24360         ndr->depth++;
24361         if (flags & NDR_SET_VALUES) {
24362                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24363         }
24364         if (flags & NDR_IN) {
24365                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24366                 ndr->depth++;
24367                 ndr_print_string(ndr, "server_name", r->in.server_name);
24368                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24369                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24370                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24371                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24372                 ndr->depth++;
24373                 if (r->in.buffer) {
24374                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24375                 }
24376                 ndr->depth--;
24377                 ndr->depth--;
24378         }
24379         if (flags & NDR_OUT) {
24380                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24381                 ndr->depth++;
24382                 ndr_print_ptr(ndr, "handle", r->out.handle);
24383                 ndr->depth++;
24384                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24385                 ndr->depth--;
24386                 ndr_print_WERROR(ndr, "result", r->out.result);
24387                 ndr->depth--;
24388         }
24389         ndr->depth--;
24390 }
24391
24392 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24393 {
24394         if (flags & NDR_IN) {
24395                 if (r->in.handle == NULL) {
24396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24397                 }
24398                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24399                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24402                 if (r->in.buffer) {
24403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24404                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24405                 }
24406         }
24407         if (flags & NDR_OUT) {
24408                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24409         }
24410         return NDR_ERR_SUCCESS;
24411 }
24412
24413 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24414 {
24415         uint32_t _ptr_buffer;
24416         TALLOC_CTX *_mem_save_handle_0;
24417         TALLOC_CTX *_mem_save_buffer_0;
24418         if (flags & NDR_IN) {
24419                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24420                         NDR_PULL_ALLOC(ndr, r->in.handle);
24421                 }
24422                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24423                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24424                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24425                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24426                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24428                 if (r->in.bufsize > 512) {
24429                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24430                 }
24431                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24432                 if (_ptr_buffer) {
24433                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24434                 } else {
24435                         r->in.buffer = NULL;
24436                 }
24437                 if (r->in.buffer) {
24438                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24439                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24440                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24441                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24442                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24444                 }
24445                 if (r->in.buffer) {
24446                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24447                 }
24448         }
24449         if (flags & NDR_OUT) {
24450                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24451         }
24452         return NDR_ERR_SUCCESS;
24453 }
24454
24455 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24456 {
24457         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24458         ndr->depth++;
24459         if (flags & NDR_SET_VALUES) {
24460                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24461         }
24462         if (flags & NDR_IN) {
24463                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24464                 ndr->depth++;
24465                 ndr_print_ptr(ndr, "handle", r->in.handle);
24466                 ndr->depth++;
24467                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24468                 ndr->depth--;
24469                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24470                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24471                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24472                 ndr->depth++;
24473                 if (r->in.buffer) {
24474                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24475                 }
24476                 ndr->depth--;
24477                 ndr->depth--;
24478         }
24479         if (flags & NDR_OUT) {
24480                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24481                 ndr->depth++;
24482                 ndr_print_WERROR(ndr, "result", r->out.result);
24483                 ndr->depth--;
24484         }
24485         ndr->depth--;
24486 }
24487
24488 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24489 {
24490         if (flags & NDR_IN) {
24491                 if (r->in.handle == NULL) {
24492                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24493                 }
24494                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24495         }
24496         if (flags & NDR_OUT) {
24497                 if (r->out.handle == NULL) {
24498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24499                 }
24500                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24501                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24502         }
24503         return NDR_ERR_SUCCESS;
24504 }
24505
24506 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24507 {
24508         TALLOC_CTX *_mem_save_handle_0;
24509         if (flags & NDR_IN) {
24510                 ZERO_STRUCT(r->out);
24511
24512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24513                         NDR_PULL_ALLOC(ndr, r->in.handle);
24514                 }
24515                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24516                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24517                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24519                 NDR_PULL_ALLOC(ndr, r->out.handle);
24520                 *r->out.handle = *r->in.handle;
24521         }
24522         if (flags & NDR_OUT) {
24523                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24524                         NDR_PULL_ALLOC(ndr, r->out.handle);
24525                 }
24526                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24527                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24528                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24529                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24530                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24531         }
24532         return NDR_ERR_SUCCESS;
24533 }
24534
24535 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24536 {
24537         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24538         ndr->depth++;
24539         if (flags & NDR_SET_VALUES) {
24540                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24541         }
24542         if (flags & NDR_IN) {
24543                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24544                 ndr->depth++;
24545                 ndr_print_ptr(ndr, "handle", r->in.handle);
24546                 ndr->depth++;
24547                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24548                 ndr->depth--;
24549                 ndr->depth--;
24550         }
24551         if (flags & NDR_OUT) {
24552                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24553                 ndr->depth++;
24554                 ndr_print_ptr(ndr, "handle", r->out.handle);
24555                 ndr->depth++;
24556                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24557                 ndr->depth--;
24558                 ndr_print_WERROR(ndr, "result", r->out.result);
24559                 ndr->depth--;
24560         }
24561         ndr->depth--;
24562 }
24563
24564 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24565 {
24566         if (flags & NDR_IN) {
24567         }
24568         if (flags & NDR_OUT) {
24569                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24570         }
24571         return NDR_ERR_SUCCESS;
24572 }
24573
24574 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24575 {
24576         if (flags & NDR_IN) {
24577         }
24578         if (flags & NDR_OUT) {
24579                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24580         }
24581         return NDR_ERR_SUCCESS;
24582 }
24583
24584 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24585 {
24586         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24587         ndr->depth++;
24588         if (flags & NDR_SET_VALUES) {
24589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24590         }
24591         if (flags & NDR_IN) {
24592                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24593                 ndr->depth++;
24594                 ndr->depth--;
24595         }
24596         if (flags & NDR_OUT) {
24597                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24598                 ndr->depth++;
24599                 ndr_print_WERROR(ndr, "result", r->out.result);
24600                 ndr->depth--;
24601         }
24602         ndr->depth--;
24603 }
24604
24605 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24606 {
24607         if (flags & NDR_IN) {
24608         }
24609         if (flags & NDR_OUT) {
24610                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24611         }
24612         return NDR_ERR_SUCCESS;
24613 }
24614
24615 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24616 {
24617         if (flags & NDR_IN) {
24618         }
24619         if (flags & NDR_OUT) {
24620                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24621         }
24622         return NDR_ERR_SUCCESS;
24623 }
24624
24625 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24626 {
24627         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24628         ndr->depth++;
24629         if (flags & NDR_SET_VALUES) {
24630                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24631         }
24632         if (flags & NDR_IN) {
24633                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24634                 ndr->depth++;
24635                 ndr->depth--;
24636         }
24637         if (flags & NDR_OUT) {
24638                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24639                 ndr->depth++;
24640                 ndr_print_WERROR(ndr, "result", r->out.result);
24641                 ndr->depth--;
24642         }
24643         ndr->depth--;
24644 }
24645
24646 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24647 {
24648         if (flags & NDR_IN) {
24649         }
24650         if (flags & NDR_OUT) {
24651                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24652         }
24653         return NDR_ERR_SUCCESS;
24654 }
24655
24656 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24657 {
24658         if (flags & NDR_IN) {
24659         }
24660         if (flags & NDR_OUT) {
24661                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24662         }
24663         return NDR_ERR_SUCCESS;
24664 }
24665
24666 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24667 {
24668         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24669         ndr->depth++;
24670         if (flags & NDR_SET_VALUES) {
24671                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24672         }
24673         if (flags & NDR_IN) {
24674                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24675                 ndr->depth++;
24676                 ndr->depth--;
24677         }
24678         if (flags & NDR_OUT) {
24679                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24680                 ndr->depth++;
24681                 ndr_print_WERROR(ndr, "result", r->out.result);
24682                 ndr->depth--;
24683         }
24684         ndr->depth--;
24685 }
24686
24687 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24688 {
24689         if (flags & NDR_IN) {
24690         }
24691         if (flags & NDR_OUT) {
24692                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24693         }
24694         return NDR_ERR_SUCCESS;
24695 }
24696
24697 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24698 {
24699         if (flags & NDR_IN) {
24700         }
24701         if (flags & NDR_OUT) {
24702                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24703         }
24704         return NDR_ERR_SUCCESS;
24705 }
24706
24707 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24708 {
24709         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24710         ndr->depth++;
24711         if (flags & NDR_SET_VALUES) {
24712                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24713         }
24714         if (flags & NDR_IN) {
24715                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24716                 ndr->depth++;
24717                 ndr->depth--;
24718         }
24719         if (flags & NDR_OUT) {
24720                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24721                 ndr->depth++;
24722                 ndr_print_WERROR(ndr, "result", r->out.result);
24723                 ndr->depth--;
24724         }
24725         ndr->depth--;
24726 }
24727
24728 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24729 {
24730         if (flags & NDR_IN) {
24731                 if (r->in.handle == NULL) {
24732                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24733                 }
24734                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24735                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24737                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24738                 if (r->in.local_machine) {
24739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24742                         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));
24743                 }
24744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24746                 if (r->in.notify_options) {
24747                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24748                 }
24749         }
24750         if (flags & NDR_OUT) {
24751                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24752         }
24753         return NDR_ERR_SUCCESS;
24754 }
24755
24756 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24757 {
24758         uint32_t _ptr_local_machine;
24759         uint32_t _ptr_notify_options;
24760         TALLOC_CTX *_mem_save_handle_0;
24761         TALLOC_CTX *_mem_save_local_machine_0;
24762         TALLOC_CTX *_mem_save_notify_options_0;
24763         if (flags & NDR_IN) {
24764                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24765                         NDR_PULL_ALLOC(ndr, r->in.handle);
24766                 }
24767                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24768                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24769                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24770                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24771                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
24773                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
24774                 if (_ptr_local_machine) {
24775                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
24776                 } else {
24777                         r->in.local_machine = NULL;
24778                 }
24779                 if (r->in.local_machine) {
24780                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
24781                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
24782                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
24783                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
24784                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
24785                                 return 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));
24786                         }
24787                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
24788                         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));
24789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
24790                 }
24791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24792                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
24793                 if (_ptr_notify_options) {
24794                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
24795                 } else {
24796                         r->in.notify_options = NULL;
24797                 }
24798                 if (r->in.notify_options) {
24799                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24800                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
24801                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24802                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
24803                 }
24804         }
24805         if (flags & NDR_OUT) {
24806                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24807         }
24808         return NDR_ERR_SUCCESS;
24809 }
24810
24811 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24812 {
24813         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24814         ndr->depth++;
24815         if (flags & NDR_SET_VALUES) {
24816                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24817         }
24818         if (flags & NDR_IN) {
24819                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24820                 ndr->depth++;
24821                 ndr_print_ptr(ndr, "handle", r->in.handle);
24822                 ndr->depth++;
24823                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24824                 ndr->depth--;
24825                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24826                 ndr_print_uint32(ndr, "options", r->in.options);
24827                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
24828                 ndr->depth++;
24829                 if (r->in.local_machine) {
24830                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
24831                 }
24832                 ndr->depth--;
24833                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24834                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
24835                 ndr->depth++;
24836                 if (r->in.notify_options) {
24837                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
24838                 }
24839                 ndr->depth--;
24840                 ndr->depth--;
24841         }
24842         if (flags & NDR_OUT) {
24843                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24844                 ndr->depth++;
24845                 ndr_print_WERROR(ndr, "result", r->out.result);
24846                 ndr->depth--;
24847         }
24848         ndr->depth--;
24849 }
24850
24851 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24852 {
24853         if (flags & NDR_IN) {
24854                 if (r->in.handle == NULL) {
24855                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24856                 }
24857                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
24859                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
24861                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24862                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24863         }
24864         if (flags & NDR_OUT) {
24865                 if (r->out.reply_result == NULL) {
24866                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24867                 }
24868                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
24869                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24870         }
24871         return NDR_ERR_SUCCESS;
24872 }
24873
24874 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
24875 {
24876         TALLOC_CTX *_mem_save_handle_0;
24877         TALLOC_CTX *_mem_save_reply_result_0;
24878         if (flags & NDR_IN) {
24879                 ZERO_STRUCT(r->out);
24880
24881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24882                         NDR_PULL_ALLOC(ndr, r->in.handle);
24883                 }
24884                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24885                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24886                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
24889                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
24891                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24892                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24893                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
24894                 ZERO_STRUCTP(r->out.reply_result);
24895         }
24896         if (flags & NDR_OUT) {
24897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24898                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
24899                 }
24900                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
24901                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
24902                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
24903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
24904                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24905         }
24906         return NDR_ERR_SUCCESS;
24907 }
24908
24909 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24910 {
24911         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
24912         ndr->depth++;
24913         if (flags & NDR_SET_VALUES) {
24914                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24915         }
24916         if (flags & NDR_IN) {
24917                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
24918                 ndr->depth++;
24919                 ndr_print_ptr(ndr, "handle", r->in.handle);
24920                 ndr->depth++;
24921                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24922                 ndr->depth--;
24923                 ndr_print_uint32(ndr, "color", r->in.color);
24924                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24925                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
24926                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
24927                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
24928                 ndr->depth--;
24929         }
24930         if (flags & NDR_OUT) {
24931                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
24932                 ndr->depth++;
24933                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
24934                 ndr->depth++;
24935                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
24936                 ndr->depth--;
24937                 ndr_print_WERROR(ndr, "result", r->out.result);
24938                 ndr->depth--;
24939         }
24940         ndr->depth--;
24941 }
24942
24943 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
24944 {
24945         if (flags & NDR_IN) {
24946                 if (r->in.handle == NULL) {
24947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24948                 }
24949                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
24951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
24952                 if (r->in.options) {
24953                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
24954                 }
24955         }
24956         if (flags & NDR_OUT) {
24957                 if (r->out.info == NULL) {
24958                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24959                 }
24960                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
24961                 if (*r->out.info) {
24962                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
24963                 }
24964                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24965         }
24966         return NDR_ERR_SUCCESS;
24967 }
24968
24969 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
24970 {
24971         uint32_t _ptr_options;
24972         uint32_t _ptr_info;
24973         TALLOC_CTX *_mem_save_handle_0;
24974         TALLOC_CTX *_mem_save_options_0;
24975         TALLOC_CTX *_mem_save_info_0;
24976         TALLOC_CTX *_mem_save_info_1;
24977         if (flags & NDR_IN) {
24978                 ZERO_STRUCT(r->out);
24979
24980                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24981                         NDR_PULL_ALLOC(ndr, r->in.handle);
24982                 }
24983                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24984                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24985                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24986                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
24988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
24989                 if (_ptr_options) {
24990                         NDR_PULL_ALLOC(ndr, r->in.options);
24991                 } else {
24992                         r->in.options = NULL;
24993                 }
24994                 if (r->in.options) {
24995                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24996                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
24997                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
24998                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
24999                 }
25000                 NDR_PULL_ALLOC(ndr, r->out.info);
25001                 ZERO_STRUCTP(r->out.info);
25002         }
25003         if (flags & NDR_OUT) {
25004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25005                         NDR_PULL_ALLOC(ndr, r->out.info);
25006                 }
25007                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25008                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25009                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25010                 if (_ptr_info) {
25011                         NDR_PULL_ALLOC(ndr, *r->out.info);
25012                 } else {
25013                         *r->out.info = NULL;
25014                 }
25015                 if (*r->out.info) {
25016                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25017                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25018                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25020                 }
25021                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25022                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25023         }
25024         return NDR_ERR_SUCCESS;
25025 }
25026
25027 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25028 {
25029         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25030         ndr->depth++;
25031         if (flags & NDR_SET_VALUES) {
25032                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25033         }
25034         if (flags & NDR_IN) {
25035                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25036                 ndr->depth++;
25037                 ndr_print_ptr(ndr, "handle", r->in.handle);
25038                 ndr->depth++;
25039                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25040                 ndr->depth--;
25041                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25042                 ndr_print_ptr(ndr, "options", r->in.options);
25043                 ndr->depth++;
25044                 if (r->in.options) {
25045                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25046                 }
25047                 ndr->depth--;
25048                 ndr->depth--;
25049         }
25050         if (flags & NDR_OUT) {
25051                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25052                 ndr->depth++;
25053                 ndr_print_ptr(ndr, "info", r->out.info);
25054                 ndr->depth++;
25055                 ndr_print_ptr(ndr, "info", *r->out.info);
25056                 ndr->depth++;
25057                 if (*r->out.info) {
25058                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25059                 }
25060                 ndr->depth--;
25061                 ndr->depth--;
25062                 ndr_print_WERROR(ndr, "result", r->out.result);
25063                 ndr->depth--;
25064         }
25065         ndr->depth--;
25066 }
25067
25068 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25069 {
25070         if (flags & NDR_IN) {
25071         }
25072         if (flags & NDR_OUT) {
25073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25074         }
25075         return NDR_ERR_SUCCESS;
25076 }
25077
25078 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25079 {
25080         if (flags & NDR_IN) {
25081         }
25082         if (flags & NDR_OUT) {
25083                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25084         }
25085         return NDR_ERR_SUCCESS;
25086 }
25087
25088 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25089 {
25090         ndr_print_struct(ndr, name, "spoolss_44");
25091         ndr->depth++;
25092         if (flags & NDR_SET_VALUES) {
25093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25094         }
25095         if (flags & NDR_IN) {
25096                 ndr_print_struct(ndr, "in", "spoolss_44");
25097                 ndr->depth++;
25098                 ndr->depth--;
25099         }
25100         if (flags & NDR_OUT) {
25101                 ndr_print_struct(ndr, "out", "spoolss_44");
25102                 ndr->depth++;
25103                 ndr_print_WERROR(ndr, "result", r->out.result);
25104                 ndr->depth--;
25105         }
25106         ndr->depth--;
25107 }
25108
25109 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25110 {
25111         if (flags & NDR_IN) {
25112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25113                 if (r->in.printername) {
25114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25117                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25118                 }
25119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25120                 if (r->in.datatype) {
25121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25125                 }
25126                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25127                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25129                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25130                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25131         }
25132         if (flags & NDR_OUT) {
25133                 if (r->out.handle == NULL) {
25134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25135                 }
25136                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25138         }
25139         return NDR_ERR_SUCCESS;
25140 }
25141
25142 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25143 {
25144         uint32_t _ptr_printername;
25145         uint32_t _ptr_datatype;
25146         TALLOC_CTX *_mem_save_printername_0;
25147         TALLOC_CTX *_mem_save_datatype_0;
25148         TALLOC_CTX *_mem_save_handle_0;
25149         if (flags & NDR_IN) {
25150                 ZERO_STRUCT(r->out);
25151
25152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25153                 if (_ptr_printername) {
25154                         NDR_PULL_ALLOC(ndr, r->in.printername);
25155                 } else {
25156                         r->in.printername = NULL;
25157                 }
25158                 if (r->in.printername) {
25159                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25160                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25161                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25162                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25163                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25164                                 return 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));
25165                         }
25166                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25167                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25169                 }
25170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25171                 if (_ptr_datatype) {
25172                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25173                 } else {
25174                         r->in.datatype = NULL;
25175                 }
25176                 if (r->in.datatype) {
25177                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25178                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25180                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25181                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25182                                 return 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));
25183                         }
25184                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25185                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25187                 }
25188                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25189                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25191                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25192                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25193                 NDR_PULL_ALLOC(ndr, r->out.handle);
25194                 ZERO_STRUCTP(r->out.handle);
25195         }
25196         if (flags & NDR_OUT) {
25197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25198                         NDR_PULL_ALLOC(ndr, r->out.handle);
25199                 }
25200                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25201                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25202                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25204                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25205         }
25206         return NDR_ERR_SUCCESS;
25207 }
25208
25209 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25210 {
25211         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25212         ndr->depth++;
25213         if (flags & NDR_SET_VALUES) {
25214                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25215         }
25216         if (flags & NDR_IN) {
25217                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25218                 ndr->depth++;
25219                 ndr_print_ptr(ndr, "printername", r->in.printername);
25220                 ndr->depth++;
25221                 if (r->in.printername) {
25222                         ndr_print_string(ndr, "printername", r->in.printername);
25223                 }
25224                 ndr->depth--;
25225                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25226                 ndr->depth++;
25227                 if (r->in.datatype) {
25228                         ndr_print_string(ndr, "datatype", r->in.datatype);
25229                 }
25230                 ndr->depth--;
25231                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25232                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25233                 ndr_print_uint32(ndr, "level", r->in.level);
25234                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25235                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25236                 ndr->depth--;
25237         }
25238         if (flags & NDR_OUT) {
25239                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25240                 ndr->depth++;
25241                 ndr_print_ptr(ndr, "handle", r->out.handle);
25242                 ndr->depth++;
25243                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25244                 ndr->depth--;
25245                 ndr_print_WERROR(ndr, "result", r->out.result);
25246                 ndr->depth--;
25247         }
25248         ndr->depth--;
25249 }
25250
25251 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25252 {
25253         if (flags & NDR_IN) {
25254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25255                 if (r->in.server) {
25256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25257                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25258                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25259                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25260                 }
25261                 if (r->in.info_ctr == NULL) {
25262                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25263                 }
25264                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25265                 if (r->in.devmode_ctr == NULL) {
25266                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25267                 }
25268                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25269                 if (r->in.secdesc_ctr == NULL) {
25270                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25271                 }
25272                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25273                 if (r->in.userlevel_ctr == NULL) {
25274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25275                 }
25276                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25277         }
25278         if (flags & NDR_OUT) {
25279                 if (r->out.handle == NULL) {
25280                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25281                 }
25282                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25283                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25284         }
25285         return NDR_ERR_SUCCESS;
25286 }
25287
25288 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25289 {
25290         uint32_t _ptr_server;
25291         TALLOC_CTX *_mem_save_server_0;
25292         TALLOC_CTX *_mem_save_info_ctr_0;
25293         TALLOC_CTX *_mem_save_devmode_ctr_0;
25294         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25295         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25296         TALLOC_CTX *_mem_save_handle_0;
25297         if (flags & NDR_IN) {
25298                 ZERO_STRUCT(r->out);
25299
25300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25301                 if (_ptr_server) {
25302                         NDR_PULL_ALLOC(ndr, r->in.server);
25303                 } else {
25304                         r->in.server = NULL;
25305                 }
25306                 if (r->in.server) {
25307                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25308                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25309                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25310                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25311                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25312                                 return 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));
25313                         }
25314                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25315                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25317                 }
25318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25319                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25320                 }
25321                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25323                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25326                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25327                 }
25328                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25329                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25330                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25332                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25333                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25334                 }
25335                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25336                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25337                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25338                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25340                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25341                 }
25342                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25343                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25344                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25346                 NDR_PULL_ALLOC(ndr, r->out.handle);
25347                 ZERO_STRUCTP(r->out.handle);
25348         }
25349         if (flags & NDR_OUT) {
25350                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25351                         NDR_PULL_ALLOC(ndr, r->out.handle);
25352                 }
25353                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25354                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25355                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25356                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25357                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25358         }
25359         return NDR_ERR_SUCCESS;
25360 }
25361
25362 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25363 {
25364         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25365         ndr->depth++;
25366         if (flags & NDR_SET_VALUES) {
25367                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25368         }
25369         if (flags & NDR_IN) {
25370                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25371                 ndr->depth++;
25372                 ndr_print_ptr(ndr, "server", r->in.server);
25373                 ndr->depth++;
25374                 if (r->in.server) {
25375                         ndr_print_string(ndr, "server", r->in.server);
25376                 }
25377                 ndr->depth--;
25378                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25379                 ndr->depth++;
25380                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25381                 ndr->depth--;
25382                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25383                 ndr->depth++;
25384                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25385                 ndr->depth--;
25386                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25387                 ndr->depth++;
25388                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25389                 ndr->depth--;
25390                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25391                 ndr->depth++;
25392                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25393                 ndr->depth--;
25394                 ndr->depth--;
25395         }
25396         if (flags & NDR_OUT) {
25397                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25398                 ndr->depth++;
25399                 ndr_print_ptr(ndr, "handle", r->out.handle);
25400                 ndr->depth++;
25401                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25402                 ndr->depth--;
25403                 ndr_print_WERROR(ndr, "result", r->out.result);
25404                 ndr->depth--;
25405         }
25406         ndr->depth--;
25407 }
25408
25409 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25410 {
25411         if (flags & NDR_IN) {
25412         }
25413         if (flags & NDR_OUT) {
25414                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25415         }
25416         return NDR_ERR_SUCCESS;
25417 }
25418
25419 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25420 {
25421         if (flags & NDR_IN) {
25422         }
25423         if (flags & NDR_OUT) {
25424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25425         }
25426         return NDR_ERR_SUCCESS;
25427 }
25428
25429 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25430 {
25431         ndr_print_struct(ndr, name, "spoolss_47");
25432         ndr->depth++;
25433         if (flags & NDR_SET_VALUES) {
25434                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25435         }
25436         if (flags & NDR_IN) {
25437                 ndr_print_struct(ndr, "in", "spoolss_47");
25438                 ndr->depth++;
25439                 ndr->depth--;
25440         }
25441         if (flags & NDR_OUT) {
25442                 ndr_print_struct(ndr, "out", "spoolss_47");
25443                 ndr->depth++;
25444                 ndr_print_WERROR(ndr, "result", r->out.result);
25445                 ndr->depth--;
25446         }
25447         ndr->depth--;
25448 }
25449
25450 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25451 {
25452         if (flags & NDR_IN) {
25453                 if (r->in.handle == NULL) {
25454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25455                 }
25456                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25460         }
25461         if (flags & NDR_OUT) {
25462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25463                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25464                 if (r->out.value_needed == NULL) {
25465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25466                 }
25467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25468                 if (r->out.printerdata_type == NULL) {
25469                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25470                 }
25471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
25472                 if (r->out.buffer == NULL) {
25473                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25474                 }
25475                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
25476                 if (r->out.data_needed == NULL) {
25477                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25478                 }
25479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25480                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25481         }
25482         return NDR_ERR_SUCCESS;
25483 }
25484
25485 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25486 {
25487         TALLOC_CTX *_mem_save_handle_0;
25488         TALLOC_CTX *_mem_save_value_needed_0;
25489         TALLOC_CTX *_mem_save_printerdata_type_0;
25490         TALLOC_CTX *_mem_save_buffer_0;
25491         TALLOC_CTX *_mem_save_data_needed_0;
25492         if (flags & NDR_IN) {
25493                 ZERO_STRUCT(r->out);
25494
25495                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25496                         NDR_PULL_ALLOC(ndr, r->in.handle);
25497                 }
25498                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25499                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25500                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25501                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25505                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25506                 ZERO_STRUCTP(r->out.value_needed);
25507                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25508                 ZERO_STRUCTP(r->out.printerdata_type);
25509                 NDR_PULL_ALLOC(ndr, r->out.buffer);
25510                 ZERO_STRUCTP(r->out.buffer);
25511                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25512                 ZERO_STRUCTP(r->out.data_needed);
25513         }
25514         if (flags & NDR_OUT) {
25515                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25516                 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));
25517                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25518                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25519                 }
25520                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25521                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25525                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25526                 }
25527                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25528                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
25529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
25530                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
25531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25532                         NDR_PULL_ALLOC(ndr, r->out.buffer);
25533                 }
25534                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25535                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
25536                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
25537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
25538                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25539                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25540                 }
25541                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25542                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25544                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25546                 if (r->out.value_name) {
25547                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25548                 }
25549         }
25550         return NDR_ERR_SUCCESS;
25551 }
25552
25553 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25554 {
25555         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25556         ndr->depth++;
25557         if (flags & NDR_SET_VALUES) {
25558                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25559         }
25560         if (flags & NDR_IN) {
25561                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25562                 ndr->depth++;
25563                 ndr_print_ptr(ndr, "handle", r->in.handle);
25564                 ndr->depth++;
25565                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25566                 ndr->depth--;
25567                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25568                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25569                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25570                 ndr->depth--;
25571         }
25572         if (flags & NDR_OUT) {
25573                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25574                 ndr->depth++;
25575                 ndr_print_string(ndr, "value_name", r->out.value_name);
25576                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25577                 ndr->depth++;
25578                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25579                 ndr->depth--;
25580                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
25581                 ndr->depth++;
25582                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
25583                 ndr->depth--;
25584                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
25585                 ndr->depth++;
25586                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
25587                 ndr->depth--;
25588                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25589                 ndr->depth++;
25590                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25591                 ndr->depth--;
25592                 ndr_print_WERROR(ndr, "result", r->out.result);
25593                 ndr->depth--;
25594         }
25595         ndr->depth--;
25596 }
25597
25598 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25599 {
25600         if (flags & NDR_IN) {
25601                 if (r->in.handle == NULL) {
25602                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25603                 }
25604                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25608                 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));
25609         }
25610         if (flags & NDR_OUT) {
25611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25612         }
25613         return NDR_ERR_SUCCESS;
25614 }
25615
25616 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25617 {
25618         TALLOC_CTX *_mem_save_handle_0;
25619         if (flags & NDR_IN) {
25620                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25621                         NDR_PULL_ALLOC(ndr, r->in.handle);
25622                 }
25623                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25624                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25625                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25626                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25627                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25628                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25629                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25630                         return 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));
25631                 }
25632                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25633                 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));
25634         }
25635         if (flags & NDR_OUT) {
25636                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25637         }
25638         return NDR_ERR_SUCCESS;
25639 }
25640
25641 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25642 {
25643         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
25644         ndr->depth++;
25645         if (flags & NDR_SET_VALUES) {
25646                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25647         }
25648         if (flags & NDR_IN) {
25649                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
25650                 ndr->depth++;
25651                 ndr_print_ptr(ndr, "handle", r->in.handle);
25652                 ndr->depth++;
25653                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25654                 ndr->depth--;
25655                 ndr_print_string(ndr, "value_name", r->in.value_name);
25656                 ndr->depth--;
25657         }
25658         if (flags & NDR_OUT) {
25659                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
25660                 ndr->depth++;
25661                 ndr_print_WERROR(ndr, "result", r->out.result);
25662                 ndr->depth--;
25663         }
25664         ndr->depth--;
25665 }
25666
25667 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
25668 {
25669         if (flags & NDR_IN) {
25670         }
25671         if (flags & NDR_OUT) {
25672                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25673         }
25674         return NDR_ERR_SUCCESS;
25675 }
25676
25677 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
25678 {
25679         if (flags & NDR_IN) {
25680         }
25681         if (flags & NDR_OUT) {
25682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25683         }
25684         return NDR_ERR_SUCCESS;
25685 }
25686
25687 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25688 {
25689         ndr_print_struct(ndr, name, "spoolss_4a");
25690         ndr->depth++;
25691         if (flags & NDR_SET_VALUES) {
25692                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25693         }
25694         if (flags & NDR_IN) {
25695                 ndr_print_struct(ndr, "in", "spoolss_4a");
25696                 ndr->depth++;
25697                 ndr->depth--;
25698         }
25699         if (flags & NDR_OUT) {
25700                 ndr_print_struct(ndr, "out", "spoolss_4a");
25701                 ndr->depth++;
25702                 ndr_print_WERROR(ndr, "result", r->out.result);
25703                 ndr->depth--;
25704         }
25705         ndr->depth--;
25706 }
25707
25708 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25709 {
25710         if (flags & NDR_IN) {
25711         }
25712         if (flags & NDR_OUT) {
25713                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25714         }
25715         return NDR_ERR_SUCCESS;
25716 }
25717
25718 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25719 {
25720         if (flags & NDR_IN) {
25721         }
25722         if (flags & NDR_OUT) {
25723                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25724         }
25725         return NDR_ERR_SUCCESS;
25726 }
25727
25728 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25729 {
25730         ndr_print_struct(ndr, name, "spoolss_4b");
25731         ndr->depth++;
25732         if (flags & NDR_SET_VALUES) {
25733                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25734         }
25735         if (flags & NDR_IN) {
25736                 ndr_print_struct(ndr, "in", "spoolss_4b");
25737                 ndr->depth++;
25738                 ndr->depth--;
25739         }
25740         if (flags & NDR_OUT) {
25741                 ndr_print_struct(ndr, "out", "spoolss_4b");
25742                 ndr->depth++;
25743                 ndr_print_WERROR(ndr, "result", r->out.result);
25744                 ndr->depth--;
25745         }
25746         ndr->depth--;
25747 }
25748
25749 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
25750 {
25751         if (flags & NDR_IN) {
25752         }
25753         if (flags & NDR_OUT) {
25754                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25755         }
25756         return NDR_ERR_SUCCESS;
25757 }
25758
25759 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
25760 {
25761         if (flags & NDR_IN) {
25762         }
25763         if (flags & NDR_OUT) {
25764                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25765         }
25766         return NDR_ERR_SUCCESS;
25767 }
25768
25769 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
25770 {
25771         ndr_print_struct(ndr, name, "spoolss_4c");
25772         ndr->depth++;
25773         if (flags & NDR_SET_VALUES) {
25774                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25775         }
25776         if (flags & NDR_IN) {
25777                 ndr_print_struct(ndr, "in", "spoolss_4c");
25778                 ndr->depth++;
25779                 ndr->depth--;
25780         }
25781         if (flags & NDR_OUT) {
25782                 ndr_print_struct(ndr, "out", "spoolss_4c");
25783                 ndr->depth++;
25784                 ndr_print_WERROR(ndr, "result", r->out.result);
25785                 ndr->depth--;
25786         }
25787         ndr->depth--;
25788 }
25789
25790 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
25791 {
25792         if (flags & NDR_IN) {
25793                 if (r->in.handle == NULL) {
25794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25795                 }
25796                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25800                 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));
25801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25804                 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));
25805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
25806                 if (r->in.buffer == NULL) {
25807                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25808                 }
25809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25810                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
25811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25812         }
25813         if (flags & NDR_OUT) {
25814                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25815         }
25816         return NDR_ERR_SUCCESS;
25817 }
25818
25819 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
25820 {
25821         TALLOC_CTX *_mem_save_handle_0;
25822         if (flags & NDR_IN) {
25823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25824                         NDR_PULL_ALLOC(ndr, r->in.handle);
25825                 }
25826                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25827                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25828                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25830                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25831                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25832                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25833                         return 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));
25834                 }
25835                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25836                 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));
25837                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25838                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25839                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25840                         return 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));
25841                 }
25842                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25843                 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));
25844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
25845                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25847                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25848                 }
25849                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25851                 if (r->in.buffer) {
25852                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
25853                 }
25854         }
25855         if (flags & NDR_OUT) {
25856                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25857         }
25858         return NDR_ERR_SUCCESS;
25859 }
25860
25861 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
25862 {
25863         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
25864         ndr->depth++;
25865         if (flags & NDR_SET_VALUES) {
25866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25867         }
25868         if (flags & NDR_IN) {
25869                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
25870                 ndr->depth++;
25871                 ndr_print_ptr(ndr, "handle", r->in.handle);
25872                 ndr->depth++;
25873                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25874                 ndr->depth--;
25875                 ndr_print_string(ndr, "key_name", r->in.key_name);
25876                 ndr_print_string(ndr, "value_name", r->in.value_name);
25877                 ndr_print_uint32(ndr, "type", r->in.type);
25878                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25879                 ndr->depth++;
25880                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
25881                 ndr->depth--;
25882                 ndr_print_uint32(ndr, "offered", r->in.offered);
25883                 ndr->depth--;
25884         }
25885         if (flags & NDR_OUT) {
25886                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
25887                 ndr->depth++;
25888                 ndr_print_WERROR(ndr, "result", r->out.result);
25889                 ndr->depth--;
25890         }
25891         ndr->depth--;
25892 }
25893
25894 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
25895 {
25896         if (flags & NDR_IN) {
25897                 if (r->in.handle == NULL) {
25898                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25899                 }
25900                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25904                 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));
25905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25908                 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));
25909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25910         }
25911         if (flags & NDR_OUT) {
25912                 if (r->out.type == NULL) {
25913                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25914                 }
25915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
25916                 if (r->out.buffer == NULL) {
25917                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25918                 }
25919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25920                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
25921                 if (r->out.needed == NULL) {
25922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25923                 }
25924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25926         }
25927         return NDR_ERR_SUCCESS;
25928 }
25929
25930 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
25931 {
25932         TALLOC_CTX *_mem_save_handle_0;
25933         TALLOC_CTX *_mem_save_type_0;
25934         TALLOC_CTX *_mem_save_needed_0;
25935         if (flags & NDR_IN) {
25936                 ZERO_STRUCT(r->out);
25937
25938                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25939                         NDR_PULL_ALLOC(ndr, r->in.handle);
25940                 }
25941                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25942                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25943                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25944                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25945                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25946                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25947                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25948                         return 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));
25949                 }
25950                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25951                 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));
25952                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25953                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25954                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25955                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
25956                 }
25957                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25958                 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));
25959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25960                 NDR_PULL_ALLOC(ndr, r->out.type);
25961                 ZERO_STRUCTP(r->out.type);
25962                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
25963                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
25964                 NDR_PULL_ALLOC(ndr, r->out.needed);
25965                 ZERO_STRUCTP(r->out.needed);
25966         }
25967         if (flags & NDR_OUT) {
25968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25969                         NDR_PULL_ALLOC(ndr, r->out.type);
25970                 }
25971                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25972                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
25973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
25974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
25975                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
25976                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25977                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
25978                 }
25979                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
25980                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25981                         NDR_PULL_ALLOC(ndr, r->out.needed);
25982                 }
25983                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25984                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25986                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25987                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25988                 if (r->out.buffer) {
25989                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
25990                 }
25991         }
25992         return NDR_ERR_SUCCESS;
25993 }
25994
25995 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
25996 {
25997         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
25998         ndr->depth++;
25999         if (flags & NDR_SET_VALUES) {
26000                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26001         }
26002         if (flags & NDR_IN) {
26003                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26004                 ndr->depth++;
26005                 ndr_print_ptr(ndr, "handle", r->in.handle);
26006                 ndr->depth++;
26007                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26008                 ndr->depth--;
26009                 ndr_print_string(ndr, "key_name", r->in.key_name);
26010                 ndr_print_string(ndr, "value_name", r->in.value_name);
26011                 ndr_print_uint32(ndr, "offered", r->in.offered);
26012                 ndr->depth--;
26013         }
26014         if (flags & NDR_OUT) {
26015                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26016                 ndr->depth++;
26017                 ndr_print_ptr(ndr, "type", r->out.type);
26018                 ndr->depth++;
26019                 ndr_print_uint32(ndr, "type", *r->out.type);
26020                 ndr->depth--;
26021                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26022                 ndr->depth++;
26023                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26024                 ndr->depth--;
26025                 ndr_print_ptr(ndr, "needed", r->out.needed);
26026                 ndr->depth++;
26027                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26028                 ndr->depth--;
26029                 ndr_print_WERROR(ndr, "result", r->out.result);
26030                 ndr->depth--;
26031         }
26032         ndr->depth--;
26033 }
26034
26035 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
26036 {
26037         if (flags & NDR_IN) {
26038                 if (r->in.handle == NULL) {
26039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26040                 }
26041                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26045                 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));
26046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26047         }
26048         if (flags & NDR_OUT) {
26049                 if (r->out.buffer == NULL) {
26050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26051                 }
26052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26053                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26054                 if (r->out.needed == NULL) {
26055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26056                 }
26057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26058                 if (r->out.count == NULL) {
26059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26060                 }
26061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26062                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26063         }
26064         return NDR_ERR_SUCCESS;
26065 }
26066
26067 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
26068 {
26069         TALLOC_CTX *_mem_save_handle_0;
26070         TALLOC_CTX *_mem_save_needed_0;
26071         TALLOC_CTX *_mem_save_count_0;
26072         if (flags & NDR_IN) {
26073                 ZERO_STRUCT(r->out);
26074
26075                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26076                         NDR_PULL_ALLOC(ndr, r->in.handle);
26077                 }
26078                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26079                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26080                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26081                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26082                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26083                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26084                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26085                         return 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));
26086                 }
26087                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26088                 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));
26089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26090                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26091                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26092                 NDR_PULL_ALLOC(ndr, r->out.needed);
26093                 ZERO_STRUCTP(r->out.needed);
26094                 NDR_PULL_ALLOC(ndr, r->out.count);
26095                 ZERO_STRUCTP(r->out.count);
26096         }
26097         if (flags & NDR_OUT) {
26098                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26099                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26100                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26101                 }
26102                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26103                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26104                         NDR_PULL_ALLOC(ndr, r->out.needed);
26105                 }
26106                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26107                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26109                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26111                         NDR_PULL_ALLOC(ndr, r->out.count);
26112                 }
26113                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26114                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26116                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26117                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26118                 if (r->out.buffer) {
26119                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26120                 }
26121         }
26122         return NDR_ERR_SUCCESS;
26123 }
26124
26125 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26126 {
26127         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26128         ndr->depth++;
26129         if (flags & NDR_SET_VALUES) {
26130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26131         }
26132         if (flags & NDR_IN) {
26133                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26134                 ndr->depth++;
26135                 ndr_print_ptr(ndr, "handle", r->in.handle);
26136                 ndr->depth++;
26137                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26138                 ndr->depth--;
26139                 ndr_print_string(ndr, "key_name", r->in.key_name);
26140                 ndr_print_uint32(ndr, "offered", r->in.offered);
26141                 ndr->depth--;
26142         }
26143         if (flags & NDR_OUT) {
26144                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26145                 ndr->depth++;
26146                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26147                 ndr->depth++;
26148                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26149                 ndr->depth--;
26150                 ndr_print_ptr(ndr, "needed", r->out.needed);
26151                 ndr->depth++;
26152                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26153                 ndr->depth--;
26154                 ndr_print_ptr(ndr, "count", r->out.count);
26155                 ndr->depth++;
26156                 ndr_print_uint32(ndr, "count", *r->out.count);
26157                 ndr->depth--;
26158                 ndr_print_WERROR(ndr, "result", r->out.result);
26159                 ndr->depth--;
26160         }
26161         ndr->depth--;
26162 }
26163
26164 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26165 {
26166         uint32_t cntr_key_buffer_1;
26167         if (flags & NDR_IN) {
26168                 if (r->in.handle == NULL) {
26169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26170                 }
26171                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26175                 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));
26176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
26177         }
26178         if (flags & NDR_OUT) {
26179                 if (r->out.key_buffer == NULL) {
26180                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26181                 }
26182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
26183                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26184                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
26185                 }
26186                 if (r->out.needed == NULL) {
26187                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26188                 }
26189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26190                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26191         }
26192         return NDR_ERR_SUCCESS;
26193 }
26194
26195 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26196 {
26197         uint32_t cntr_key_buffer_1;
26198         TALLOC_CTX *_mem_save_handle_0;
26199         TALLOC_CTX *_mem_save_key_buffer_1;
26200         TALLOC_CTX *_mem_save_needed_0;
26201         if (flags & NDR_IN) {
26202                 ZERO_STRUCT(r->out);
26203
26204                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26205                         NDR_PULL_ALLOC(ndr, r->in.handle);
26206                 }
26207                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26208                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26209                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26211                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26212                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26213                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26214                         return 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));
26215                 }
26216                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26217                 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));
26218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
26219                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
26220                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
26221                 NDR_PULL_ALLOC(ndr, r->out.needed);
26222                 ZERO_STRUCTP(r->out.needed);
26223         }
26224         if (flags & NDR_OUT) {
26225                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
26226                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26227                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
26228                 }
26229                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26230                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
26231                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26232                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
26233                 }
26234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26235                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26236                         NDR_PULL_ALLOC(ndr, r->out.needed);
26237                 }
26238                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26239                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26241                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26242                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26243                 if (r->out.key_buffer) {
26244                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
26245                 }
26246         }
26247         return NDR_ERR_SUCCESS;
26248 }
26249
26250 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26251 {
26252         uint32_t cntr_key_buffer_1;
26253         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26254         ndr->depth++;
26255         if (flags & NDR_SET_VALUES) {
26256                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26257         }
26258         if (flags & NDR_IN) {
26259                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26260                 ndr->depth++;
26261                 ndr_print_ptr(ndr, "handle", r->in.handle);
26262                 ndr->depth++;
26263                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26264                 ndr->depth--;
26265                 ndr_print_string(ndr, "key_name", r->in.key_name);
26266                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
26267                 ndr->depth--;
26268         }
26269         if (flags & NDR_OUT) {
26270                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26271                 ndr->depth++;
26272                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26273                 ndr->depth++;
26274                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
26275                 ndr->depth++;
26276                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
26277                         char *idx_1=NULL;
26278                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
26279                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
26280                                 free(idx_1);
26281                         }
26282                 }
26283                 ndr->depth--;
26284                 ndr->depth--;
26285                 ndr_print_ptr(ndr, "needed", r->out.needed);
26286                 ndr->depth++;
26287                 ndr_print_uint32(ndr, "needed", *r->out.needed);
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_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *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.key_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.key_name, CH_UTF16)));
26305                 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));
26306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26309                 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));
26310         }
26311         if (flags & NDR_OUT) {
26312                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26313         }
26314         return NDR_ERR_SUCCESS;
26315 }
26316
26317 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26318 {
26319         TALLOC_CTX *_mem_save_handle_0;
26320         if (flags & NDR_IN) {
26321                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26322                         NDR_PULL_ALLOC(ndr, r->in.handle);
26323                 }
26324                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26325                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26326                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26327                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26328                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26329                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26330                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26331                         return 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));
26332                 }
26333                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26334                 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));
26335                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26336                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26337                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26338                         return 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));
26339                 }
26340                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26341                 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));
26342         }
26343         if (flags & NDR_OUT) {
26344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26345         }
26346         return NDR_ERR_SUCCESS;
26347 }
26348
26349 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26350 {
26351         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26352         ndr->depth++;
26353         if (flags & NDR_SET_VALUES) {
26354                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26355         }
26356         if (flags & NDR_IN) {
26357                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26358                 ndr->depth++;
26359                 ndr_print_ptr(ndr, "handle", r->in.handle);
26360                 ndr->depth++;
26361                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26362                 ndr->depth--;
26363                 ndr_print_string(ndr, "key_name", r->in.key_name);
26364                 ndr_print_string(ndr, "value_name", r->in.value_name);
26365                 ndr->depth--;
26366         }
26367         if (flags & NDR_OUT) {
26368                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26369                 ndr->depth++;
26370                 ndr_print_WERROR(ndr, "result", r->out.result);
26371                 ndr->depth--;
26372         }
26373         ndr->depth--;
26374 }
26375
26376 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26377 {
26378         if (flags & NDR_IN) {
26379                 if (r->in.handle == NULL) {
26380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26381                 }
26382                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26386                 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));
26387         }
26388         if (flags & NDR_OUT) {
26389                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26390         }
26391         return NDR_ERR_SUCCESS;
26392 }
26393
26394 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26395 {
26396         TALLOC_CTX *_mem_save_handle_0;
26397         if (flags & NDR_IN) {
26398                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26399                         NDR_PULL_ALLOC(ndr, r->in.handle);
26400                 }
26401                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26402                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26403                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26404                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26405                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26406                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26407                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26408                         return 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));
26409                 }
26410                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26411                 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));
26412         }
26413         if (flags & NDR_OUT) {
26414                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26415         }
26416         return NDR_ERR_SUCCESS;
26417 }
26418
26419 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26420 {
26421         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26422         ndr->depth++;
26423         if (flags & NDR_SET_VALUES) {
26424                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26425         }
26426         if (flags & NDR_IN) {
26427                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26428                 ndr->depth++;
26429                 ndr_print_ptr(ndr, "handle", r->in.handle);
26430                 ndr->depth++;
26431                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26432                 ndr->depth--;
26433                 ndr_print_string(ndr, "key_name", r->in.key_name);
26434                 ndr->depth--;
26435         }
26436         if (flags & NDR_OUT) {
26437                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26438                 ndr->depth++;
26439                 ndr_print_WERROR(ndr, "result", r->out.result);
26440                 ndr->depth--;
26441         }
26442         ndr->depth--;
26443 }
26444
26445 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26446 {
26447         if (flags & NDR_IN) {
26448         }
26449         if (flags & NDR_OUT) {
26450                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26451         }
26452         return NDR_ERR_SUCCESS;
26453 }
26454
26455 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26456 {
26457         if (flags & NDR_IN) {
26458         }
26459         if (flags & NDR_OUT) {
26460                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26461         }
26462         return NDR_ERR_SUCCESS;
26463 }
26464
26465 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26466 {
26467         ndr_print_struct(ndr, name, "spoolss_53");
26468         ndr->depth++;
26469         if (flags & NDR_SET_VALUES) {
26470                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26471         }
26472         if (flags & NDR_IN) {
26473                 ndr_print_struct(ndr, "in", "spoolss_53");
26474                 ndr->depth++;
26475                 ndr->depth--;
26476         }
26477         if (flags & NDR_OUT) {
26478                 ndr_print_struct(ndr, "out", "spoolss_53");
26479                 ndr->depth++;
26480                 ndr_print_WERROR(ndr, "result", r->out.result);
26481                 ndr->depth--;
26482         }
26483         ndr->depth--;
26484 }
26485
26486 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26487 {
26488         if (flags & NDR_IN) {
26489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26490                 if (r->in.server) {
26491                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26492                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26493                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26494                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26495                 }
26496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26499                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26503                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26504                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26506         }
26507         if (flags & NDR_OUT) {
26508                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26509         }
26510         return NDR_ERR_SUCCESS;
26511 }
26512
26513 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26514 {
26515         uint32_t _ptr_server;
26516         TALLOC_CTX *_mem_save_server_0;
26517         if (flags & NDR_IN) {
26518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26519                 if (_ptr_server) {
26520                         NDR_PULL_ALLOC(ndr, r->in.server);
26521                 } else {
26522                         r->in.server = NULL;
26523                 }
26524                 if (r->in.server) {
26525                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26526                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26528                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26529                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26530                                 return 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));
26531                         }
26532                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26533                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26535                 }
26536                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26537                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26538                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26539                         return 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));
26540                 }
26541                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26542                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26543                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26544                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26545                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26546                         return 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));
26547                 }
26548                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26549                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26550                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26552         }
26553         if (flags & NDR_OUT) {
26554                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26555         }
26556         return NDR_ERR_SUCCESS;
26557 }
26558
26559 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26560 {
26561         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26562         ndr->depth++;
26563         if (flags & NDR_SET_VALUES) {
26564                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26565         }
26566         if (flags & NDR_IN) {
26567                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26568                 ndr->depth++;
26569                 ndr_print_ptr(ndr, "server", r->in.server);
26570                 ndr->depth++;
26571                 if (r->in.server) {
26572                         ndr_print_string(ndr, "server", r->in.server);
26573                 }
26574                 ndr->depth--;
26575                 ndr_print_string(ndr, "architecture", r->in.architecture);
26576                 ndr_print_string(ndr, "driver", r->in.driver);
26577                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26578                 ndr_print_uint32(ndr, "version", r->in.version);
26579                 ndr->depth--;
26580         }
26581         if (flags & NDR_OUT) {
26582                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26583                 ndr->depth++;
26584                 ndr_print_WERROR(ndr, "result", r->out.result);
26585                 ndr->depth--;
26586         }
26587         ndr->depth--;
26588 }
26589
26590 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26591 {
26592         if (flags & NDR_IN) {
26593         }
26594         if (flags & NDR_OUT) {
26595                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26596         }
26597         return NDR_ERR_SUCCESS;
26598 }
26599
26600 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26601 {
26602         if (flags & NDR_IN) {
26603         }
26604         if (flags & NDR_OUT) {
26605                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26606         }
26607         return NDR_ERR_SUCCESS;
26608 }
26609
26610 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26611 {
26612         ndr_print_struct(ndr, name, "spoolss_55");
26613         ndr->depth++;
26614         if (flags & NDR_SET_VALUES) {
26615                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26616         }
26617         if (flags & NDR_IN) {
26618                 ndr_print_struct(ndr, "in", "spoolss_55");
26619                 ndr->depth++;
26620                 ndr->depth--;
26621         }
26622         if (flags & NDR_OUT) {
26623                 ndr_print_struct(ndr, "out", "spoolss_55");
26624                 ndr->depth++;
26625                 ndr_print_WERROR(ndr, "result", r->out.result);
26626                 ndr->depth--;
26627         }
26628         ndr->depth--;
26629 }
26630
26631 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26632 {
26633         if (flags & NDR_IN) {
26634         }
26635         if (flags & NDR_OUT) {
26636                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26637         }
26638         return NDR_ERR_SUCCESS;
26639 }
26640
26641 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26642 {
26643         if (flags & NDR_IN) {
26644         }
26645         if (flags & NDR_OUT) {
26646                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26647         }
26648         return NDR_ERR_SUCCESS;
26649 }
26650
26651 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26652 {
26653         ndr_print_struct(ndr, name, "spoolss_56");
26654         ndr->depth++;
26655         if (flags & NDR_SET_VALUES) {
26656                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26657         }
26658         if (flags & NDR_IN) {
26659                 ndr_print_struct(ndr, "in", "spoolss_56");
26660                 ndr->depth++;
26661                 ndr->depth--;
26662         }
26663         if (flags & NDR_OUT) {
26664                 ndr_print_struct(ndr, "out", "spoolss_56");
26665                 ndr->depth++;
26666                 ndr_print_WERROR(ndr, "result", r->out.result);
26667                 ndr->depth--;
26668         }
26669         ndr->depth--;
26670 }
26671
26672 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
26673 {
26674         if (flags & NDR_IN) {
26675         }
26676         if (flags & NDR_OUT) {
26677                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26678         }
26679         return NDR_ERR_SUCCESS;
26680 }
26681
26682 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
26683 {
26684         if (flags & NDR_IN) {
26685         }
26686         if (flags & NDR_OUT) {
26687                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26688         }
26689         return NDR_ERR_SUCCESS;
26690 }
26691
26692 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
26693 {
26694         ndr_print_struct(ndr, name, "spoolss_57");
26695         ndr->depth++;
26696         if (flags & NDR_SET_VALUES) {
26697                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26698         }
26699         if (flags & NDR_IN) {
26700                 ndr_print_struct(ndr, "in", "spoolss_57");
26701                 ndr->depth++;
26702                 ndr->depth--;
26703         }
26704         if (flags & NDR_OUT) {
26705                 ndr_print_struct(ndr, "out", "spoolss_57");
26706                 ndr->depth++;
26707                 ndr_print_WERROR(ndr, "result", r->out.result);
26708                 ndr->depth--;
26709         }
26710         ndr->depth--;
26711 }
26712
26713 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
26714 {
26715         if (flags & NDR_IN) {
26716                 if (r->in.handle == NULL) {
26717                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26718                 }
26719                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26723                 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));
26724                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
26725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
26726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26727                 if (r->in.status_code == NULL) {
26728                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26729                 }
26730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
26731         }
26732         if (flags & NDR_OUT) {
26733                 if (r->out.out_data == NULL) {
26734                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26735                 }
26736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26737                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
26738                 if (r->out.needed == NULL) {
26739                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26740                 }
26741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26742                 if (r->out.status_code == NULL) {
26743                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26744                 }
26745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
26746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26747         }
26748         return NDR_ERR_SUCCESS;
26749 }
26750
26751 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
26752 {
26753         TALLOC_CTX *_mem_save_handle_0;
26754         TALLOC_CTX *_mem_save_needed_0;
26755         TALLOC_CTX *_mem_save_status_code_0;
26756         if (flags & NDR_IN) {
26757                 ZERO_STRUCT(r->out);
26758
26759                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26760                         NDR_PULL_ALLOC(ndr, r->in.handle);
26761                 }
26762                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26763                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26764                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26765                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26766                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
26767                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
26768                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
26769                         return 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));
26770                 }
26771                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
26772                 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));
26773                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
26774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
26775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
26776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26777                         NDR_PULL_ALLOC(ndr, r->in.status_code);
26778                 }
26779                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26780                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
26781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
26782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26783                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
26784                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
26785                 NDR_PULL_ALLOC(ndr, r->out.needed);
26786                 ZERO_STRUCTP(r->out.needed);
26787                 NDR_PULL_ALLOC(ndr, r->out.status_code);
26788                 *r->out.status_code = *r->in.status_code;
26789         }
26790         if (flags & NDR_OUT) {
26791                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
26792                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26793                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
26794                 }
26795                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
26796                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26797                         NDR_PULL_ALLOC(ndr, r->out.needed);
26798                 }
26799                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26800                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26804                         NDR_PULL_ALLOC(ndr, r->out.status_code);
26805                 }
26806                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26807                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
26808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
26809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26810                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26811                 if (r->out.out_data) {
26812                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
26813                 }
26814         }
26815         return NDR_ERR_SUCCESS;
26816 }
26817
26818 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
26819 {
26820         ndr_print_struct(ndr, name, "spoolss_XcvData");
26821         ndr->depth++;
26822         if (flags & NDR_SET_VALUES) {
26823                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26824         }
26825         if (flags & NDR_IN) {
26826                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
26827                 ndr->depth++;
26828                 ndr_print_ptr(ndr, "handle", r->in.handle);
26829                 ndr->depth++;
26830                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26831                 ndr->depth--;
26832                 ndr_print_string(ndr, "function_name", r->in.function_name);
26833                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
26834                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
26835                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
26836                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
26837                 ndr->depth++;
26838                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
26839                 ndr->depth--;
26840                 ndr->depth--;
26841         }
26842         if (flags & NDR_OUT) {
26843                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
26844                 ndr->depth++;
26845                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
26846                 ndr->depth++;
26847                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
26848                 ndr->depth--;
26849                 ndr_print_ptr(ndr, "needed", r->out.needed);
26850                 ndr->depth++;
26851                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26852                 ndr->depth--;
26853                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
26854                 ndr->depth++;
26855                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
26856                 ndr->depth--;
26857                 ndr_print_WERROR(ndr, "result", r->out.result);
26858                 ndr->depth--;
26859         }
26860         ndr->depth--;
26861 }
26862
26863 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
26864 {
26865         if (flags & NDR_IN) {
26866                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26867                 if (r->in.servername) {
26868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26872                 }
26873                 if (r->in.info_ctr == NULL) {
26874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26875                 }
26876                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26877                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
26878         }
26879         if (flags & NDR_OUT) {
26880                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26881         }
26882         return NDR_ERR_SUCCESS;
26883 }
26884
26885 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
26886 {
26887         uint32_t _ptr_servername;
26888         TALLOC_CTX *_mem_save_servername_0;
26889         TALLOC_CTX *_mem_save_info_ctr_0;
26890         if (flags & NDR_IN) {
26891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26892                 if (_ptr_servername) {
26893                         NDR_PULL_ALLOC(ndr, r->in.servername);
26894                 } else {
26895                         r->in.servername = NULL;
26896                 }
26897                 if (r->in.servername) {
26898                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26899                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26900                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26901                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26902                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26903                                 return 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));
26904                         }
26905                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26906                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26908                 }
26909                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26910                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26911                 }
26912                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26913                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26914                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26915                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26916                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
26917         }
26918         if (flags & NDR_OUT) {
26919                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26920         }
26921         return NDR_ERR_SUCCESS;
26922 }
26923
26924 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
26925 {
26926         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
26927         ndr->depth++;
26928         if (flags & NDR_SET_VALUES) {
26929                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26930         }
26931         if (flags & NDR_IN) {
26932                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
26933                 ndr->depth++;
26934                 ndr_print_ptr(ndr, "servername", r->in.servername);
26935                 ndr->depth++;
26936                 if (r->in.servername) {
26937                         ndr_print_string(ndr, "servername", r->in.servername);
26938                 }
26939                 ndr->depth--;
26940                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26941                 ndr->depth++;
26942                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26943                 ndr->depth--;
26944                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
26945                 ndr->depth--;
26946         }
26947         if (flags & NDR_OUT) {
26948                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
26949                 ndr->depth++;
26950                 ndr_print_WERROR(ndr, "result", r->out.result);
26951                 ndr->depth--;
26952         }
26953         ndr->depth--;
26954 }
26955
26956 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
26957 {
26958         if (flags & NDR_IN) {
26959         }
26960         if (flags & NDR_OUT) {
26961                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26962         }
26963         return NDR_ERR_SUCCESS;
26964 }
26965
26966 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
26967 {
26968         if (flags & NDR_IN) {
26969         }
26970         if (flags & NDR_OUT) {
26971                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26972         }
26973         return NDR_ERR_SUCCESS;
26974 }
26975
26976 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
26977 {
26978         ndr_print_struct(ndr, name, "spoolss_5a");
26979         ndr->depth++;
26980         if (flags & NDR_SET_VALUES) {
26981                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26982         }
26983         if (flags & NDR_IN) {
26984                 ndr_print_struct(ndr, "in", "spoolss_5a");
26985                 ndr->depth++;
26986                 ndr->depth--;
26987         }
26988         if (flags & NDR_OUT) {
26989                 ndr_print_struct(ndr, "out", "spoolss_5a");
26990                 ndr->depth++;
26991                 ndr_print_WERROR(ndr, "result", r->out.result);
26992                 ndr->depth--;
26993         }
26994         ndr->depth--;
26995 }
26996
26997 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
26998 {
26999         if (flags & NDR_IN) {
27000         }
27001         if (flags & NDR_OUT) {
27002                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27003         }
27004         return NDR_ERR_SUCCESS;
27005 }
27006
27007 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27008 {
27009         if (flags & NDR_IN) {
27010         }
27011         if (flags & NDR_OUT) {
27012                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27013         }
27014         return NDR_ERR_SUCCESS;
27015 }
27016
27017 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27018 {
27019         ndr_print_struct(ndr, name, "spoolss_5b");
27020         ndr->depth++;
27021         if (flags & NDR_SET_VALUES) {
27022                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27023         }
27024         if (flags & NDR_IN) {
27025                 ndr_print_struct(ndr, "in", "spoolss_5b");
27026                 ndr->depth++;
27027                 ndr->depth--;
27028         }
27029         if (flags & NDR_OUT) {
27030                 ndr_print_struct(ndr, "out", "spoolss_5b");
27031                 ndr->depth++;
27032                 ndr_print_WERROR(ndr, "result", r->out.result);
27033                 ndr->depth--;
27034         }
27035         ndr->depth--;
27036 }
27037
27038 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27039 {
27040         if (flags & NDR_IN) {
27041         }
27042         if (flags & NDR_OUT) {
27043                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27044         }
27045         return NDR_ERR_SUCCESS;
27046 }
27047
27048 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27049 {
27050         if (flags & NDR_IN) {
27051         }
27052         if (flags & NDR_OUT) {
27053                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27054         }
27055         return NDR_ERR_SUCCESS;
27056 }
27057
27058 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27059 {
27060         ndr_print_struct(ndr, name, "spoolss_5c");
27061         ndr->depth++;
27062         if (flags & NDR_SET_VALUES) {
27063                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27064         }
27065         if (flags & NDR_IN) {
27066                 ndr_print_struct(ndr, "in", "spoolss_5c");
27067                 ndr->depth++;
27068                 ndr->depth--;
27069         }
27070         if (flags & NDR_OUT) {
27071                 ndr_print_struct(ndr, "out", "spoolss_5c");
27072                 ndr->depth++;
27073                 ndr_print_WERROR(ndr, "result", r->out.result);
27074                 ndr->depth--;
27075         }
27076         ndr->depth--;
27077 }
27078
27079 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27080 {
27081         if (flags & NDR_IN) {
27082         }
27083         if (flags & NDR_OUT) {
27084                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27085         }
27086         return NDR_ERR_SUCCESS;
27087 }
27088
27089 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27090 {
27091         if (flags & NDR_IN) {
27092         }
27093         if (flags & NDR_OUT) {
27094                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27095         }
27096         return NDR_ERR_SUCCESS;
27097 }
27098
27099 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27100 {
27101         ndr_print_struct(ndr, name, "spoolss_5d");
27102         ndr->depth++;
27103         if (flags & NDR_SET_VALUES) {
27104                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27105         }
27106         if (flags & NDR_IN) {
27107                 ndr_print_struct(ndr, "in", "spoolss_5d");
27108                 ndr->depth++;
27109                 ndr->depth--;
27110         }
27111         if (flags & NDR_OUT) {
27112                 ndr_print_struct(ndr, "out", "spoolss_5d");
27113                 ndr->depth++;
27114                 ndr_print_WERROR(ndr, "result", r->out.result);
27115                 ndr->depth--;
27116         }
27117         ndr->depth--;
27118 }
27119
27120 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27121 {
27122         if (flags & NDR_IN) {
27123         }
27124         if (flags & NDR_OUT) {
27125                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27126         }
27127         return NDR_ERR_SUCCESS;
27128 }
27129
27130 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27131 {
27132         if (flags & NDR_IN) {
27133         }
27134         if (flags & NDR_OUT) {
27135                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27136         }
27137         return NDR_ERR_SUCCESS;
27138 }
27139
27140 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27141 {
27142         ndr_print_struct(ndr, name, "spoolss_5e");
27143         ndr->depth++;
27144         if (flags & NDR_SET_VALUES) {
27145                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27146         }
27147         if (flags & NDR_IN) {
27148                 ndr_print_struct(ndr, "in", "spoolss_5e");
27149                 ndr->depth++;
27150                 ndr->depth--;
27151         }
27152         if (flags & NDR_OUT) {
27153                 ndr_print_struct(ndr, "out", "spoolss_5e");
27154                 ndr->depth++;
27155                 ndr_print_WERROR(ndr, "result", r->out.result);
27156                 ndr->depth--;
27157         }
27158         ndr->depth--;
27159 }
27160
27161 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27162 {
27163         if (flags & NDR_IN) {
27164         }
27165         if (flags & NDR_OUT) {
27166                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27167         }
27168         return NDR_ERR_SUCCESS;
27169 }
27170
27171 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27172 {
27173         if (flags & NDR_IN) {
27174         }
27175         if (flags & NDR_OUT) {
27176                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27177         }
27178         return NDR_ERR_SUCCESS;
27179 }
27180
27181 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27182 {
27183         ndr_print_struct(ndr, name, "spoolss_5f");
27184         ndr->depth++;
27185         if (flags & NDR_SET_VALUES) {
27186                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27187         }
27188         if (flags & NDR_IN) {
27189                 ndr_print_struct(ndr, "in", "spoolss_5f");
27190                 ndr->depth++;
27191                 ndr->depth--;
27192         }
27193         if (flags & NDR_OUT) {
27194                 ndr_print_struct(ndr, "out", "spoolss_5f");
27195                 ndr->depth++;
27196                 ndr_print_WERROR(ndr, "result", r->out.result);
27197                 ndr->depth--;
27198         }
27199         ndr->depth--;
27200 }
27201
27202 static const struct ndr_interface_call spoolss_calls[] = {
27203         {
27204                 "spoolss_EnumPrinters",
27205                 sizeof(struct spoolss_EnumPrinters),
27206                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27207                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27208                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27209                 false,
27210         },
27211         {
27212                 "spoolss_OpenPrinter",
27213                 sizeof(struct spoolss_OpenPrinter),
27214                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27215                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27216                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27217                 false,
27218         },
27219         {
27220                 "spoolss_SetJob",
27221                 sizeof(struct spoolss_SetJob),
27222                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27223                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27224                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27225                 false,
27226         },
27227         {
27228                 "spoolss_GetJob",
27229                 sizeof(struct spoolss_GetJob),
27230                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27231                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27232                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27233                 false,
27234         },
27235         {
27236                 "spoolss_EnumJobs",
27237                 sizeof(struct spoolss_EnumJobs),
27238                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27239                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27240                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27241                 false,
27242         },
27243         {
27244                 "spoolss_AddPrinter",
27245                 sizeof(struct spoolss_AddPrinter),
27246                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27247                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27248                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27249                 false,
27250         },
27251         {
27252                 "spoolss_DeletePrinter",
27253                 sizeof(struct spoolss_DeletePrinter),
27254                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27255                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27256                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27257                 false,
27258         },
27259         {
27260                 "spoolss_SetPrinter",
27261                 sizeof(struct spoolss_SetPrinter),
27262                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27263                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27264                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27265                 false,
27266         },
27267         {
27268                 "spoolss_GetPrinter",
27269                 sizeof(struct spoolss_GetPrinter),
27270                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27271                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27272                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27273                 false,
27274         },
27275         {
27276                 "spoolss_AddPrinterDriver",
27277                 sizeof(struct spoolss_AddPrinterDriver),
27278                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27279                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27280                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27281                 false,
27282         },
27283         {
27284                 "spoolss_EnumPrinterDrivers",
27285                 sizeof(struct spoolss_EnumPrinterDrivers),
27286                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27287                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27288                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27289                 false,
27290         },
27291         {
27292                 "spoolss_GetPrinterDriver",
27293                 sizeof(struct spoolss_GetPrinterDriver),
27294                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27295                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27296                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27297                 false,
27298         },
27299         {
27300                 "spoolss_GetPrinterDriverDirectory",
27301                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27302                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27303                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27304                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27305                 false,
27306         },
27307         {
27308                 "spoolss_DeletePrinterDriver",
27309                 sizeof(struct spoolss_DeletePrinterDriver),
27310                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27311                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27312                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27313                 false,
27314         },
27315         {
27316                 "spoolss_AddPrintProcessor",
27317                 sizeof(struct spoolss_AddPrintProcessor),
27318                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27319                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27320                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27321                 false,
27322         },
27323         {
27324                 "spoolss_EnumPrintProcessors",
27325                 sizeof(struct spoolss_EnumPrintProcessors),
27326                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27327                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27328                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27329                 false,
27330         },
27331         {
27332                 "spoolss_GetPrintProcessorDirectory",
27333                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27334                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27335                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27336                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27337                 false,
27338         },
27339         {
27340                 "spoolss_StartDocPrinter",
27341                 sizeof(struct spoolss_StartDocPrinter),
27342                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27343                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27344                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27345                 false,
27346         },
27347         {
27348                 "spoolss_StartPagePrinter",
27349                 sizeof(struct spoolss_StartPagePrinter),
27350                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27351                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27352                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27353                 false,
27354         },
27355         {
27356                 "spoolss_WritePrinter",
27357                 sizeof(struct spoolss_WritePrinter),
27358                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27359                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27360                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27361                 false,
27362         },
27363         {
27364                 "spoolss_EndPagePrinter",
27365                 sizeof(struct spoolss_EndPagePrinter),
27366                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27367                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27368                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27369                 false,
27370         },
27371         {
27372                 "spoolss_AbortPrinter",
27373                 sizeof(struct spoolss_AbortPrinter),
27374                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27375                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27376                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27377                 false,
27378         },
27379         {
27380                 "spoolss_ReadPrinter",
27381                 sizeof(struct spoolss_ReadPrinter),
27382                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27383                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27384                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27385                 false,
27386         },
27387         {
27388                 "spoolss_EndDocPrinter",
27389                 sizeof(struct spoolss_EndDocPrinter),
27390                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27391                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27392                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27393                 false,
27394         },
27395         {
27396                 "spoolss_AddJob",
27397                 sizeof(struct spoolss_AddJob),
27398                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27399                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27400                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27401                 false,
27402         },
27403         {
27404                 "spoolss_ScheduleJob",
27405                 sizeof(struct spoolss_ScheduleJob),
27406                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27407                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27408                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27409                 false,
27410         },
27411         {
27412                 "spoolss_GetPrinterData",
27413                 sizeof(struct spoolss_GetPrinterData),
27414                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27415                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27416                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27417                 false,
27418         },
27419         {
27420                 "spoolss_SetPrinterData",
27421                 sizeof(struct spoolss_SetPrinterData),
27422                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27423                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27424                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27425                 false,
27426         },
27427         {
27428                 "spoolss_WaitForPrinterChange",
27429                 sizeof(struct spoolss_WaitForPrinterChange),
27430                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27431                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27432                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27433                 false,
27434         },
27435         {
27436                 "spoolss_ClosePrinter",
27437                 sizeof(struct spoolss_ClosePrinter),
27438                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27439                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27440                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27441                 false,
27442         },
27443         {
27444                 "spoolss_AddForm",
27445                 sizeof(struct spoolss_AddForm),
27446                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27447                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27448                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27449                 false,
27450         },
27451         {
27452                 "spoolss_DeleteForm",
27453                 sizeof(struct spoolss_DeleteForm),
27454                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27455                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27456                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27457                 false,
27458         },
27459         {
27460                 "spoolss_GetForm",
27461                 sizeof(struct spoolss_GetForm),
27462                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27463                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27464                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27465                 false,
27466         },
27467         {
27468                 "spoolss_SetForm",
27469                 sizeof(struct spoolss_SetForm),
27470                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27471                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27472                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27473                 false,
27474         },
27475         {
27476                 "spoolss_EnumForms",
27477                 sizeof(struct spoolss_EnumForms),
27478                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27479                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27480                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27481                 false,
27482         },
27483         {
27484                 "spoolss_EnumPorts",
27485                 sizeof(struct spoolss_EnumPorts),
27486                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27487                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27488                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27489                 false,
27490         },
27491         {
27492                 "spoolss_EnumMonitors",
27493                 sizeof(struct spoolss_EnumMonitors),
27494                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27495                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27496                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27497                 false,
27498         },
27499         {
27500                 "spoolss_AddPort",
27501                 sizeof(struct spoolss_AddPort),
27502                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27503                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27504                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27505                 false,
27506         },
27507         {
27508                 "spoolss_ConfigurePort",
27509                 sizeof(struct spoolss_ConfigurePort),
27510                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27511                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27512                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27513                 false,
27514         },
27515         {
27516                 "spoolss_DeletePort",
27517                 sizeof(struct spoolss_DeletePort),
27518                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27519                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27520                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27521                 false,
27522         },
27523         {
27524                 "spoolss_CreatePrinterIC",
27525                 sizeof(struct spoolss_CreatePrinterIC),
27526                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27527                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27528                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27529                 false,
27530         },
27531         {
27532                 "spoolss_PlayGDIScriptOnPrinterIC",
27533                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27534                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27535                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27536                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27537                 false,
27538         },
27539         {
27540                 "spoolss_DeletePrinterIC",
27541                 sizeof(struct spoolss_DeletePrinterIC),
27542                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27543                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27544                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27545                 false,
27546         },
27547         {
27548                 "spoolss_AddPrinterConnection",
27549                 sizeof(struct spoolss_AddPrinterConnection),
27550                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27551                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27552                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27553                 false,
27554         },
27555         {
27556                 "spoolss_DeletePrinterConnection",
27557                 sizeof(struct spoolss_DeletePrinterConnection),
27558                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27559                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27560                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27561                 false,
27562         },
27563         {
27564                 "spoolss_PrinterMessageBox",
27565                 sizeof(struct spoolss_PrinterMessageBox),
27566                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27567                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27568                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27569                 false,
27570         },
27571         {
27572                 "spoolss_AddMonitor",
27573                 sizeof(struct spoolss_AddMonitor),
27574                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27575                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27576                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27577                 false,
27578         },
27579         {
27580                 "spoolss_DeleteMonitor",
27581                 sizeof(struct spoolss_DeleteMonitor),
27582                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27583                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27584                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27585                 false,
27586         },
27587         {
27588                 "spoolss_DeletePrintProcessor",
27589                 sizeof(struct spoolss_DeletePrintProcessor),
27590                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27591                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27592                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27593                 false,
27594         },
27595         {
27596                 "spoolss_AddPrintProvidor",
27597                 sizeof(struct spoolss_AddPrintProvidor),
27598                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27599                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27600                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27601                 false,
27602         },
27603         {
27604                 "spoolss_DeletePrintProvidor",
27605                 sizeof(struct spoolss_DeletePrintProvidor),
27606                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27607                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27608                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27609                 false,
27610         },
27611         {
27612                 "spoolss_EnumPrintProcDataTypes",
27613                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27614                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27615                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27616                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27617                 false,
27618         },
27619         {
27620                 "spoolss_ResetPrinter",
27621                 sizeof(struct spoolss_ResetPrinter),
27622                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27623                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27624                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27625                 false,
27626         },
27627         {
27628                 "spoolss_GetPrinterDriver2",
27629                 sizeof(struct spoolss_GetPrinterDriver2),
27630                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27631                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27632                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27633                 false,
27634         },
27635         {
27636                 "spoolss_FindFirstPrinterChangeNotification",
27637                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27638                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27639                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27640                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27641                 false,
27642         },
27643         {
27644                 "spoolss_FindNextPrinterChangeNotification",
27645                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27646                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27647                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27648                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27649                 false,
27650         },
27651         {
27652                 "spoolss_FindClosePrinterNotify",
27653                 sizeof(struct spoolss_FindClosePrinterNotify),
27654                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27655                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27656                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27657                 false,
27658         },
27659         {
27660                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27661                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27662                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27663                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27664                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27665                 false,
27666         },
27667         {
27668                 "spoolss_ReplyOpenPrinter",
27669                 sizeof(struct spoolss_ReplyOpenPrinter),
27670                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27671                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27672                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
27673                 false,
27674         },
27675         {
27676                 "spoolss_RouterReplyPrinter",
27677                 sizeof(struct spoolss_RouterReplyPrinter),
27678                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
27679                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
27680                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
27681                 false,
27682         },
27683         {
27684                 "spoolss_ReplyClosePrinter",
27685                 sizeof(struct spoolss_ReplyClosePrinter),
27686                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
27687                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
27688                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
27689                 false,
27690         },
27691         {
27692                 "spoolss_AddPortEx",
27693                 sizeof(struct spoolss_AddPortEx),
27694                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
27695                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
27696                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
27697                 false,
27698         },
27699         {
27700                 "spoolss_RouterFindFirstPrinterChangeNotification",
27701                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
27702                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
27703                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
27704                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
27705                 false,
27706         },
27707         {
27708                 "spoolss_SpoolerInit",
27709                 sizeof(struct spoolss_SpoolerInit),
27710                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
27711                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
27712                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
27713                 false,
27714         },
27715         {
27716                 "spoolss_ResetPrinterEx",
27717                 sizeof(struct spoolss_ResetPrinterEx),
27718                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
27719                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
27720                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
27721                 false,
27722         },
27723         {
27724                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
27725                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
27726                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27727                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27728                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27729                 false,
27730         },
27731         {
27732                 "spoolss_RouterReplyPrinterEx",
27733                 sizeof(struct spoolss_RouterReplyPrinterEx),
27734                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
27735                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
27736                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
27737                 false,
27738         },
27739         {
27740                 "spoolss_RouterRefreshPrinterChangeNotify",
27741                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
27742                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
27743                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
27744                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
27745                 false,
27746         },
27747         {
27748                 "spoolss_44",
27749                 sizeof(struct spoolss_44),
27750                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
27751                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
27752                 (ndr_print_function_t) ndr_print_spoolss_44,
27753                 false,
27754         },
27755         {
27756                 "spoolss_OpenPrinterEx",
27757                 sizeof(struct spoolss_OpenPrinterEx),
27758                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
27759                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
27760                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
27761                 false,
27762         },
27763         {
27764                 "spoolss_AddPrinterEx",
27765                 sizeof(struct spoolss_AddPrinterEx),
27766                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
27767                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
27768                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
27769                 false,
27770         },
27771         {
27772                 "spoolss_47",
27773                 sizeof(struct spoolss_47),
27774                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
27775                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
27776                 (ndr_print_function_t) ndr_print_spoolss_47,
27777                 false,
27778         },
27779         {
27780                 "spoolss_EnumPrinterData",
27781                 sizeof(struct spoolss_EnumPrinterData),
27782                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
27783                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
27784                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
27785                 false,
27786         },
27787         {
27788                 "spoolss_DeletePrinterData",
27789                 sizeof(struct spoolss_DeletePrinterData),
27790                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
27791                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
27792                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
27793                 false,
27794         },
27795         {
27796                 "spoolss_4a",
27797                 sizeof(struct spoolss_4a),
27798                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
27799                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
27800                 (ndr_print_function_t) ndr_print_spoolss_4a,
27801                 false,
27802         },
27803         {
27804                 "spoolss_4b",
27805                 sizeof(struct spoolss_4b),
27806                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
27807                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
27808                 (ndr_print_function_t) ndr_print_spoolss_4b,
27809                 false,
27810         },
27811         {
27812                 "spoolss_4c",
27813                 sizeof(struct spoolss_4c),
27814                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
27815                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
27816                 (ndr_print_function_t) ndr_print_spoolss_4c,
27817                 false,
27818         },
27819         {
27820                 "spoolss_SetPrinterDataEx",
27821                 sizeof(struct spoolss_SetPrinterDataEx),
27822                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
27823                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
27824                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
27825                 false,
27826         },
27827         {
27828                 "spoolss_GetPrinterDataEx",
27829                 sizeof(struct spoolss_GetPrinterDataEx),
27830                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
27831                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
27832                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
27833                 false,
27834         },
27835         {
27836                 "spoolss_EnumPrinterDataEx",
27837                 sizeof(struct spoolss_EnumPrinterDataEx),
27838                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
27839                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
27840                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
27841                 false,
27842         },
27843         {
27844                 "spoolss_EnumPrinterKey",
27845                 sizeof(struct spoolss_EnumPrinterKey),
27846                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
27847                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
27848                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
27849                 false,
27850         },
27851         {
27852                 "spoolss_DeletePrinterDataEx",
27853                 sizeof(struct spoolss_DeletePrinterDataEx),
27854                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
27855                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
27856                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
27857                 false,
27858         },
27859         {
27860                 "spoolss_DeletePrinterKey",
27861                 sizeof(struct spoolss_DeletePrinterKey),
27862                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
27863                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
27864                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
27865                 false,
27866         },
27867         {
27868                 "spoolss_53",
27869                 sizeof(struct spoolss_53),
27870                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
27871                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
27872                 (ndr_print_function_t) ndr_print_spoolss_53,
27873                 false,
27874         },
27875         {
27876                 "spoolss_DeletePrinterDriverEx",
27877                 sizeof(struct spoolss_DeletePrinterDriverEx),
27878                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
27879                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
27880                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
27881                 false,
27882         },
27883         {
27884                 "spoolss_55",
27885                 sizeof(struct spoolss_55),
27886                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
27887                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
27888                 (ndr_print_function_t) ndr_print_spoolss_55,
27889                 false,
27890         },
27891         {
27892                 "spoolss_56",
27893                 sizeof(struct spoolss_56),
27894                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
27895                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
27896                 (ndr_print_function_t) ndr_print_spoolss_56,
27897                 false,
27898         },
27899         {
27900                 "spoolss_57",
27901                 sizeof(struct spoolss_57),
27902                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
27903                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
27904                 (ndr_print_function_t) ndr_print_spoolss_57,
27905                 false,
27906         },
27907         {
27908                 "spoolss_XcvData",
27909                 sizeof(struct spoolss_XcvData),
27910                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
27911                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
27912                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
27913                 false,
27914         },
27915         {
27916                 "spoolss_AddPrinterDriverEx",
27917                 sizeof(struct spoolss_AddPrinterDriverEx),
27918                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
27919                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
27920                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
27921                 false,
27922         },
27923         {
27924                 "spoolss_5a",
27925                 sizeof(struct spoolss_5a),
27926                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
27927                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
27928                 (ndr_print_function_t) ndr_print_spoolss_5a,
27929                 false,
27930         },
27931         {
27932                 "spoolss_5b",
27933                 sizeof(struct spoolss_5b),
27934                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
27935                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
27936                 (ndr_print_function_t) ndr_print_spoolss_5b,
27937                 false,
27938         },
27939         {
27940                 "spoolss_5c",
27941                 sizeof(struct spoolss_5c),
27942                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
27943                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
27944                 (ndr_print_function_t) ndr_print_spoolss_5c,
27945                 false,
27946         },
27947         {
27948                 "spoolss_5d",
27949                 sizeof(struct spoolss_5d),
27950                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
27951                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
27952                 (ndr_print_function_t) ndr_print_spoolss_5d,
27953                 false,
27954         },
27955         {
27956                 "spoolss_5e",
27957                 sizeof(struct spoolss_5e),
27958                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
27959                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
27960                 (ndr_print_function_t) ndr_print_spoolss_5e,
27961                 false,
27962         },
27963         {
27964                 "spoolss_5f",
27965                 sizeof(struct spoolss_5f),
27966                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
27967                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
27968                 (ndr_print_function_t) ndr_print_spoolss_5f,
27969                 false,
27970         },
27971         { NULL, 0, NULL, NULL, NULL, false }
27972 };
27973
27974 static const char * const spoolss_endpoint_strings[] = {
27975         "ncacn_np:[\\pipe\\spoolss]",
27976 };
27977
27978 static const struct ndr_interface_string_array spoolss_endpoints = {
27979         .count  = 1,
27980         .names  = spoolss_endpoint_strings
27981 };
27982
27983 static const char * const spoolss_authservice_strings[] = {
27984         "host",
27985 };
27986
27987 static const struct ndr_interface_string_array spoolss_authservices = {
27988         .count  = 1,
27989         .names  = spoolss_authservice_strings
27990 };
27991
27992
27993 const struct ndr_interface_table ndr_table_spoolss = {
27994         .name           = "spoolss",
27995         .syntax_id      = {
27996                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
27997                 NDR_SPOOLSS_VERSION
27998         },
27999         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28000         .num_calls      = 96,
28001         .calls          = spoolss_calls,
28002         .endpoints      = &spoolss_endpoints,
28003         .authservices   = &spoolss_authservices
28004 };
28005