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, 5));
  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, 5));
  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_enum_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_enum_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_enum_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_enum_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_enum_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_enum_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_enum_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_enum_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 5));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 5));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 516 {
 517         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 518 }
 519
 520 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 521 {
 522         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 527 {
 528         uint32_t v;
 529         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 530         *r = v;
 531         return NDR_ERR_SUCCESS;
 532 }
 533
 534 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 535 {
 536         ndr_print_uint32(ndr, name, r);
 537         ndr->depth++;
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 566         ndr->depth--;
 567 }
 568
 569 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 570 {
 571         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 572         return NDR_ERR_SUCCESS;
 573 }
 574
 575 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 576 {
 577         uint16_t v;
 578         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 579         *r = v;
 580         return NDR_ERR_SUCCESS;
 581 }
 582
 583 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 584 {
 585         const char *val = NULL;
 586
 587         switch (r) {
 588                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 589                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 590                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 591         }
 592         ndr_print_enum(ndr, name, "ENUM", val, r);
 593 }
 594
 595 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 596 {
 597         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 598         return NDR_ERR_SUCCESS;
 599 }
 600
 601 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 602 {
 603         uint16_t v;
 604         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 605         *r = v;
 606         return NDR_ERR_SUCCESS;
 607 }
 608
 609 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 610 {
 611         const char *val = NULL;
 612
 613         switch (r) {
 614                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 615                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 616         }
 617         ndr_print_enum(ndr, name, "ENUM", val, r);
 618 }
 619
 620 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 621 {
 622         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 623         return NDR_ERR_SUCCESS;
 624 }
 625
 626 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 627 {
 628         uint16_t v;
 629         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 630         *r = v;
 631         return NDR_ERR_SUCCESS;
 632 }
 633
 634 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 635 {
 636         const char *val = NULL;
 637
 638         switch (r) {
 639                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 640                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 641                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 642                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 643                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 644                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 645                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 646                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 647                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 648                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 649                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 650                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 651                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 652                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 653                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 654                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 655                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 656                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 657                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 658                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 659                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 660                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 661                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 662                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 663                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 664                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 665                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 666                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 667                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 668                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 669                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 670                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 671                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 672                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 673                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 674                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 675                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 676                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 677                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 678                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 679                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 680                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 681                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 682                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 683                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 684                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 685                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 686                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 687                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 688                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 689                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 690                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 691                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 692                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 693                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 694                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 695                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 696                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 697                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 698                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 699                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 700                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 701                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 702                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 703                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 704                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 705                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 706                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 707                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 708                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 709                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 710                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 711                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 712                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 713                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 714                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 715                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 716                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 717                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 718                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 719                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 720                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 721                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 722                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 723                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 724                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 725                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 726                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 727                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 728                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 729                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 730         }
 731         ndr_print_enum(ndr, name, "ENUM", val, r);
 732 }
 733
 734 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 735 {
 736         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 737         return NDR_ERR_SUCCESS;
 738 }
 739
 740 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 741 {
 742         uint16_t v;
 743         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 744         *r = v;
 745         return NDR_ERR_SUCCESS;
 746 }
 747
 748 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 749 {
 750         const char *val = NULL;
 751
 752         switch (r) {
 753                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 754                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 755                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 756                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 757                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 758                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 759                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 760                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 761                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 762                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 763                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 764                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 765                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 766         }
 767         ndr_print_enum(ndr, name, "ENUM", val, r);
 768 }
 769
 770 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 771 {
 772         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 773         return NDR_ERR_SUCCESS;
 774 }
 775
 776 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 777 {
 778         uint16_t v;
 779         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 780         *r = v;
 781         return NDR_ERR_SUCCESS;
 782 }
 783
 784 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 785 {
 786         const char *val = NULL;
 787
 788         switch (r) {
 789                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 790                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 791                 case DMRES_LOW: val = "DMRES_LOW"; break;
 792                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 793         }
 794         ndr_print_enum(ndr, name, "ENUM", val, r);
 795 }
 796
 797 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 798 {
 799         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 800         return NDR_ERR_SUCCESS;
 801 }
 802
 803 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 804 {
 805         uint16_t v;
 806         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 807         *r = v;
 808         return NDR_ERR_SUCCESS;
 809 }
 810
 811 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 812 {
 813         const char *val = NULL;
 814
 815         switch (r) {
 816                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 817                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 818         }
 819         ndr_print_enum(ndr, name, "ENUM", val, r);
 820 }
 821
 822 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 823 {
 824         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 825         return NDR_ERR_SUCCESS;
 826 }
 827
 828 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 829 {
 830         uint16_t v;
 831         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 832         *r = v;
 833         return NDR_ERR_SUCCESS;
 834 }
 835
 836 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 837 {
 838         const char *val = NULL;
 839
 840         switch (r) {
 841                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 842                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 843                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 844         }
 845         ndr_print_enum(ndr, name, "ENUM", val, r);
 846 }
 847
 848 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 849 {
 850         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 851         return NDR_ERR_SUCCESS;
 852 }
 853
 854 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 855 {
 856         uint16_t v;
 857         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 858         *r = v;
 859         return NDR_ERR_SUCCESS;
 860 }
 861
 862 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 863 {
 864         const char *val = NULL;
 865
 866         switch (r) {
 867                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 868                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 869                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 870                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 871         }
 872         ndr_print_enum(ndr, name, "ENUM", val, r);
 873 }
 874
 875 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 876 {
 877         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 878         return NDR_ERR_SUCCESS;
 879 }
 880
 881 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 882 {
 883         uint16_t v;
 884         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 885         *r = v;
 886         return NDR_ERR_SUCCESS;
 887 }
 888
 889 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 890 {
 891         const char *val = NULL;
 892
 893         switch (r) {
 894                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 895                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 896         }
 897         ndr_print_enum(ndr, name, "ENUM", val, r);
 898 }
 899
 900 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 901 {
 902         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 903         return NDR_ERR_SUCCESS;
 904 }
 905
 906 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 907 {
 908         uint32_t v;
 909         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 910         *r = v;
 911         return NDR_ERR_SUCCESS;
 912 }
 913
 914 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 915 {
 916         const char *val = NULL;
 917
 918         switch (r) {
 919                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 920                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 921         }
 922         ndr_print_enum(ndr, name, "ENUM", val, r);
 923 }
 924
 925 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 926 {
 927         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 928         return NDR_ERR_SUCCESS;
 929 }
 930
 931 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 932 {
 933         uint32_t v;
 934         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 935         *r = v;
 936         return NDR_ERR_SUCCESS;
 937 }
 938
 939 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 940 {
 941         const char *val = NULL;
 942
 943         switch (r) {
 944                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 945                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 946                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 947                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 948         }
 949         ndr_print_enum(ndr, name, "ENUM", val, r);
 950 }
 951
 952 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 953 {
 954         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 955         return NDR_ERR_SUCCESS;
 956 }
 957
 958 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 959 {
 960         uint32_t v;
 961         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 962         *r = v;
 963         return NDR_ERR_SUCCESS;
 964 }
 965
 966 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 967 {
 968         const char *val = NULL;
 969
 970         switch (r) {
 971                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 972                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 973                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 974                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 975         }
 976         ndr_print_enum(ndr, name, "ENUM", val, r);
 977 }
 978
 979 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 980 {
 981         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 982         return NDR_ERR_SUCCESS;
 983 }
 984
 985 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
 986 {
 987         uint32_t v;
 988         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 989         *r = v;
 990         return NDR_ERR_SUCCESS;
 991 }
 992
 993 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
 994 {
 995         const char *val = NULL;
 996
 997         switch (r) {
 998                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
 999                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1000                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1001         }
1002         ndr_print_enum(ndr, name, "ENUM", val, r);
1003 }
1004
1005 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1006 {
1007         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1008         return NDR_ERR_SUCCESS;
1009 }
1010
1011 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1012 {
1013         uint32_t v;
1014         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1015         *r = v;
1016         return NDR_ERR_SUCCESS;
1017 }
1018
1019 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1020 {
1021         const char *val = NULL;
1022
1023         switch (r) {
1024                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1025                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1026                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1027                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1028                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1029                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1030                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1031                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1032                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1033                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1034         }
1035         ndr_print_enum(ndr, name, "ENUM", val, r);
1036 }
1037
1038 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1039 {
1040         if (ndr_flags & NDR_SCALARS) {
1041                 NDR_CHECK(ndr_push_align(ndr, 4));
1042                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
1043                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1044                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1045                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1046                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1047                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1048                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1049                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1050                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1051                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1052                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1053                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1054                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1055                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1056                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1057                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1059                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1060                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1061                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
1062                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1066                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1070                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1076                 {
1077                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1079                         {
1080                                 struct ndr_push *_ndr_driverextra_data;
1081                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1082                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1083                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1084                         }
1085                         ndr->flags = _flags_save_DATA_BLOB;
1086                 }
1087         }
1088         if (ndr_flags & NDR_BUFFERS) {
1089         }
1090         return NDR_ERR_SUCCESS;
1091 }
1092
1093 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1094 {
1095         if (ndr_flags & NDR_SCALARS) {
1096                 NDR_CHECK(ndr_pull_align(ndr, 4));
1097                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
1098                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1099                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1100                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1101                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1102                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1103                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1104                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1105                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1106                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1107                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1108                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1109                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1110                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1111                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1112                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1113                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1114                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1115                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1116                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
1117                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1121                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1123                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1126                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1131                 {
1132                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1134                         {
1135                                 struct ndr_pull *_ndr_driverextra_data;
1136                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1137                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1138                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1139                         }
1140                         ndr->flags = _flags_save_DATA_BLOB;
1141                 }
1142         }
1143         if (ndr_flags & NDR_BUFFERS) {
1144         }
1145         return NDR_ERR_SUCCESS;
1146 }
1147
1148 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1149 {
1150         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1151         ndr->depth++;
1152         ndr_print_string(ndr, "devicename", r->devicename);
1153         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1154         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1155         ndr_print_uint16(ndr, "size", r->size);
1156         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1157         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1158         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1159         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1160         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1161         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1162         ndr_print_uint16(ndr, "scale", r->scale);
1163         ndr_print_uint16(ndr, "copies", r->copies);
1164         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1165         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1166         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1167         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1168         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1169         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1170         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1171         ndr_print_string(ndr, "formname", r->formname);
1172         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1173         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1174         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1175         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1176         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1177         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1178         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1179         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1180         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1181         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1182         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1183         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1184         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1185         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1186         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1187         ndr->depth--;
1188 }
1189
1190 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1191 {
1192         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1193 }
1194
1195 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1196 {
1197         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1198         return NDR_ERR_SUCCESS;
1199 }
1200
1201 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1202 {
1203         uint32_t v;
1204         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1205         *r = v;
1206         return NDR_ERR_SUCCESS;
1207 }
1208
1209 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1210 {
1211         ndr_print_uint32(ndr, name, r);
1212         ndr->depth++;
1213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1214         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1215         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1216         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1217         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1218         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1219         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1220         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1221         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1222         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1223         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1224         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1225         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1226         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1232         ndr->depth--;
1233 }
1234
1235 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1236 {
1237         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1238         return NDR_ERR_SUCCESS;
1239 }
1240
1241 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1242 {
1243         uint32_t v;
1244         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1245         *r = v;
1246         return NDR_ERR_SUCCESS;
1247 }
1248
1249 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1250 {
1251         ndr_print_uint32(ndr, name, r);
1252         ndr->depth++;
1253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1269         ndr->depth--;
1270 }
1271
1272 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1273 {
1274         if (ndr_flags & NDR_SCALARS) {
1275                 NDR_CHECK(ndr_push_align(ndr, 5));
1276                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1277                 {
1278                         uint32_t _flags_save_string = ndr->flags;
1279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1280                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
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_push_relative_ptr1(ndr, r->name));
1287                         ndr->flags = _flags_save_string;
1288                 }
1289                 {
1290                         uint32_t _flags_save_string = ndr->flags;
1291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1292                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1293                         ndr->flags = _flags_save_string;
1294                 }
1295         }
1296         if (ndr_flags & NDR_BUFFERS) {
1297                 {
1298                         uint32_t _flags_save_string = ndr->flags;
1299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1300                         if (r->description) {
1301                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
1302                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1303                         }
1304                         ndr->flags = _flags_save_string;
1305                 }
1306                 {
1307                         uint32_t _flags_save_string = ndr->flags;
1308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1309                         if (r->name) {
1310                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
1311                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1312                         }
1313                         ndr->flags = _flags_save_string;
1314                 }
1315                 {
1316                         uint32_t _flags_save_string = ndr->flags;
1317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1318                         if (r->comment) {
1319                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1320                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324         }
1325         return NDR_ERR_SUCCESS;
1326 }
1327
1328 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1329 {
1330         uint32_t _ptr_description;
1331         TALLOC_CTX *_mem_save_description_0;
1332         uint32_t _ptr_name;
1333         TALLOC_CTX *_mem_save_name_0;
1334         uint32_t _ptr_comment;
1335         TALLOC_CTX *_mem_save_comment_0;
1336         if (ndr_flags & NDR_SCALARS) {
1337                 NDR_CHECK(ndr_pull_align(ndr, 5));
1338                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1339                 {
1340                         uint32_t _flags_save_string = ndr->flags;
1341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1343                         if (_ptr_description) {
1344                                 NDR_PULL_ALLOC(ndr, r->description);
1345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1346                         } else {
1347                                 r->description = NULL;
1348                         }
1349                         ndr->flags = _flags_save_string;
1350                 }
1351                 {
1352                         uint32_t _flags_save_string = ndr->flags;
1353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1355                         if (_ptr_name) {
1356                                 NDR_PULL_ALLOC(ndr, r->name);
1357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1358                         } else {
1359                                 r->name = NULL;
1360                         }
1361                         ndr->flags = _flags_save_string;
1362                 }
1363                 {
1364                         uint32_t _flags_save_string = ndr->flags;
1365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1366                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1367                         if (_ptr_comment) {
1368                                 NDR_PULL_ALLOC(ndr, r->comment);
1369                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1370                         } else {
1371                                 r->comment = NULL;
1372                         }
1373                         ndr->flags = _flags_save_string;
1374                 }
1375         }
1376         if (ndr_flags & NDR_BUFFERS) {
1377                 {
1378                         uint32_t _flags_save_string = ndr->flags;
1379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1380                         if (r->description) {
1381                                 uint32_t _relative_save_offset;
1382                                 _relative_save_offset = ndr->offset;
1383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1384                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1385                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1386                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1387                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1388                                 ndr->offset = _relative_save_offset;
1389                         }
1390                         ndr->flags = _flags_save_string;
1391                 }
1392                 {
1393                         uint32_t _flags_save_string = ndr->flags;
1394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1395                         if (r->name) {
1396                                 uint32_t _relative_save_offset;
1397                                 _relative_save_offset = ndr->offset;
1398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1399                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1400                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1403                                 ndr->offset = _relative_save_offset;
1404                         }
1405                         ndr->flags = _flags_save_string;
1406                 }
1407                 {
1408                         uint32_t _flags_save_string = ndr->flags;
1409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1410                         if (r->comment) {
1411                                 uint32_t _relative_save_offset;
1412                                 _relative_save_offset = ndr->offset;
1413                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1414                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1415                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1416                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1417                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1418                                 ndr->offset = _relative_save_offset;
1419                         }
1420                         ndr->flags = _flags_save_string;
1421                 }
1422         }
1423         return NDR_ERR_SUCCESS;
1424 }
1425
1426 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1427 {
1428         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1429         ndr->depth++;
1430         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1431         ndr_print_ptr(ndr, "description", r->description);
1432         ndr->depth++;
1433         if (r->description) {
1434                 ndr_print_string(ndr, "description", r->description);
1435         }
1436         ndr->depth--;
1437         ndr_print_ptr(ndr, "name", r->name);
1438         ndr->depth++;
1439         if (r->name) {
1440                 ndr_print_string(ndr, "name", r->name);
1441         }
1442         ndr->depth--;
1443         ndr_print_ptr(ndr, "comment", r->comment);
1444         ndr->depth++;
1445         if (r->comment) {
1446                 ndr_print_string(ndr, "comment", r->comment);
1447         }
1448         ndr->depth--;
1449         ndr->depth--;
1450 }
1451
1452 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1453 {
1454         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1455 }
1456
1457 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1458 {
1459         if (ndr_flags & NDR_SCALARS) {
1460                 NDR_CHECK(ndr_push_align(ndr, 5));
1461                 {
1462                         uint32_t _flags_save_string = ndr->flags;
1463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1464                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1465                         ndr->flags = _flags_save_string;
1466                 }
1467                 {
1468                         uint32_t _flags_save_string = ndr->flags;
1469                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1470                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1471                         ndr->flags = _flags_save_string;
1472                 }
1473                 {
1474                         uint32_t _flags_save_string = ndr->flags;
1475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1476                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1477                         ndr->flags = _flags_save_string;
1478                 }
1479                 {
1480                         uint32_t _flags_save_string = ndr->flags;
1481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1482                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1483                         ndr->flags = _flags_save_string;
1484                 }
1485                 {
1486                         uint32_t _flags_save_string = ndr->flags;
1487                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1488                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1489                         ndr->flags = _flags_save_string;
1490                 }
1491                 {
1492                         uint32_t _flags_save_string = ndr->flags;
1493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1494                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1495                         ndr->flags = _flags_save_string;
1496                 }
1497                 {
1498                         uint32_t _flags_save_string = ndr->flags;
1499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1500                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1501                         ndr->flags = _flags_save_string;
1502                 }
1503                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1504                 {
1505                         uint32_t _flags_save_string = ndr->flags;
1506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1508                         ndr->flags = _flags_save_string;
1509                 }
1510                 {
1511                         uint32_t _flags_save_string = ndr->flags;
1512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1514                         ndr->flags = _flags_save_string;
1515                 }
1516                 {
1517                         uint32_t _flags_save_string = ndr->flags;
1518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1520                         ndr->flags = _flags_save_string;
1521                 }
1522                 {
1523                         uint32_t _flags_save_string = ndr->flags;
1524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1526                         ndr->flags = _flags_save_string;
1527                 }
1528                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1529                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1534                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1537         }
1538         if (ndr_flags & NDR_BUFFERS) {
1539                 {
1540                         uint32_t _flags_save_string = ndr->flags;
1541                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1542                         if (r->servername) {
1543                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1544                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1545                         }
1546                         ndr->flags = _flags_save_string;
1547                 }
1548                 {
1549                         uint32_t _flags_save_string = ndr->flags;
1550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1551                         if (r->printername) {
1552                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1553                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1554                         }
1555                         ndr->flags = _flags_save_string;
1556                 }
1557                 {
1558                         uint32_t _flags_save_string = ndr->flags;
1559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1560                         if (r->sharename) {
1561                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1562                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1563                         }
1564                         ndr->flags = _flags_save_string;
1565                 }
1566                 {
1567                         uint32_t _flags_save_string = ndr->flags;
1568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1569                         if (r->portname) {
1570                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1571                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1572                         }
1573                         ndr->flags = _flags_save_string;
1574                 }
1575                 {
1576                         uint32_t _flags_save_string = ndr->flags;
1577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1578                         if (r->drivername) {
1579                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1580                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1581                         }
1582                         ndr->flags = _flags_save_string;
1583                 }
1584                 {
1585                         uint32_t _flags_save_string = ndr->flags;
1586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1587                         if (r->comment) {
1588                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1589                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1590                         }
1591                         ndr->flags = _flags_save_string;
1592                 }
1593                 {
1594                         uint32_t _flags_save_string = ndr->flags;
1595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1596                         if (r->location) {
1597                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1598                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1599                         }
1600                         ndr->flags = _flags_save_string;
1601                 }
1602                 if (r->devmode) {
1603                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1604                         {
1605                                 struct ndr_push *_ndr_devmode;
1606                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1607                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1608                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1609                         }
1610                 }
1611                 {
1612                         uint32_t _flags_save_string = ndr->flags;
1613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1614                         if (r->sepfile) {
1615                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1616                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1617                         }
1618                         ndr->flags = _flags_save_string;
1619                 }
1620                 {
1621                         uint32_t _flags_save_string = ndr->flags;
1622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1623                         if (r->printprocessor) {
1624                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1625                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1626                         }
1627                         ndr->flags = _flags_save_string;
1628                 }
1629                 {
1630                         uint32_t _flags_save_string = ndr->flags;
1631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1632                         if (r->datatype) {
1633                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1634                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1635                         }
1636                         ndr->flags = _flags_save_string;
1637                 }
1638                 {
1639                         uint32_t _flags_save_string = ndr->flags;
1640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1641                         if (r->parameters) {
1642                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1643                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1644                         }
1645                         ndr->flags = _flags_save_string;
1646                 }
1647                 if (r->secdesc) {
1648                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1649                         {
1650                                 struct ndr_push *_ndr_secdesc;
1651                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1652                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1653                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1654                         }
1655                 }
1656         }
1657         return NDR_ERR_SUCCESS;
1658 }
1659
1660 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1661 {
1662         uint32_t _ptr_servername;
1663         TALLOC_CTX *_mem_save_servername_0;
1664         uint32_t _ptr_printername;
1665         TALLOC_CTX *_mem_save_printername_0;
1666         uint32_t _ptr_sharename;
1667         TALLOC_CTX *_mem_save_sharename_0;
1668         uint32_t _ptr_portname;
1669         TALLOC_CTX *_mem_save_portname_0;
1670         uint32_t _ptr_drivername;
1671         TALLOC_CTX *_mem_save_drivername_0;
1672         uint32_t _ptr_comment;
1673         TALLOC_CTX *_mem_save_comment_0;
1674         uint32_t _ptr_location;
1675         TALLOC_CTX *_mem_save_location_0;
1676         uint32_t _ptr_devmode;
1677         TALLOC_CTX *_mem_save_devmode_0;
1678         uint32_t _ptr_sepfile;
1679         TALLOC_CTX *_mem_save_sepfile_0;
1680         uint32_t _ptr_printprocessor;
1681         TALLOC_CTX *_mem_save_printprocessor_0;
1682         uint32_t _ptr_datatype;
1683         TALLOC_CTX *_mem_save_datatype_0;
1684         uint32_t _ptr_parameters;
1685         TALLOC_CTX *_mem_save_parameters_0;
1686         uint32_t _ptr_secdesc;
1687         TALLOC_CTX *_mem_save_secdesc_0;
1688         if (ndr_flags & NDR_SCALARS) {
1689                 NDR_CHECK(ndr_pull_align(ndr, 5));
1690                 {
1691                         uint32_t _flags_save_string = ndr->flags;
1692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1694                         if (_ptr_servername) {
1695                                 NDR_PULL_ALLOC(ndr, r->servername);
1696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1697                         } else {
1698                                 r->servername = NULL;
1699                         }
1700                         ndr->flags = _flags_save_string;
1701                 }
1702                 {
1703                         uint32_t _flags_save_string = ndr->flags;
1704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1706                         if (_ptr_printername) {
1707                                 NDR_PULL_ALLOC(ndr, r->printername);
1708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1709                         } else {
1710                                 r->printername = NULL;
1711                         }
1712                         ndr->flags = _flags_save_string;
1713                 }
1714                 {
1715                         uint32_t _flags_save_string = ndr->flags;
1716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1718                         if (_ptr_sharename) {
1719                                 NDR_PULL_ALLOC(ndr, r->sharename);
1720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1721                         } else {
1722                                 r->sharename = NULL;
1723                         }
1724                         ndr->flags = _flags_save_string;
1725                 }
1726                 {
1727                         uint32_t _flags_save_string = ndr->flags;
1728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1730                         if (_ptr_portname) {
1731                                 NDR_PULL_ALLOC(ndr, r->portname);
1732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1733                         } else {
1734                                 r->portname = NULL;
1735                         }
1736                         ndr->flags = _flags_save_string;
1737                 }
1738                 {
1739                         uint32_t _flags_save_string = ndr->flags;
1740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1742                         if (_ptr_drivername) {
1743                                 NDR_PULL_ALLOC(ndr, r->drivername);
1744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1745                         } else {
1746                                 r->drivername = NULL;
1747                         }
1748                         ndr->flags = _flags_save_string;
1749                 }
1750                 {
1751                         uint32_t _flags_save_string = ndr->flags;
1752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1754                         if (_ptr_comment) {
1755                                 NDR_PULL_ALLOC(ndr, r->comment);
1756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1757                         } else {
1758                                 r->comment = NULL;
1759                         }
1760                         ndr->flags = _flags_save_string;
1761                 }
1762                 {
1763                         uint32_t _flags_save_string = ndr->flags;
1764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1766                         if (_ptr_location) {
1767                                 NDR_PULL_ALLOC(ndr, r->location);
1768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1769                         } else {
1770                                 r->location = NULL;
1771                         }
1772                         ndr->flags = _flags_save_string;
1773                 }
1774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1775                 if (_ptr_devmode) {
1776                         NDR_PULL_ALLOC(ndr, r->devmode);
1777                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1778                 } else {
1779                         r->devmode = NULL;
1780                 }
1781                 {
1782                         uint32_t _flags_save_string = ndr->flags;
1783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1784                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1785                         if (_ptr_sepfile) {
1786                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1787                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1788                         } else {
1789                                 r->sepfile = NULL;
1790                         }
1791                         ndr->flags = _flags_save_string;
1792                 }
1793                 {
1794                         uint32_t _flags_save_string = ndr->flags;
1795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1796                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1797                         if (_ptr_printprocessor) {
1798                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1799                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1800                         } else {
1801                                 r->printprocessor = NULL;
1802                         }
1803                         ndr->flags = _flags_save_string;
1804                 }
1805                 {
1806                         uint32_t _flags_save_string = ndr->flags;
1807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1808                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1809                         if (_ptr_datatype) {
1810                                 NDR_PULL_ALLOC(ndr, r->datatype);
1811                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1812                         } else {
1813                                 r->datatype = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1821                         if (_ptr_parameters) {
1822                                 NDR_PULL_ALLOC(ndr, r->parameters);
1823                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1824                         } else {
1825                                 r->parameters = NULL;
1826                         }
1827                         ndr->flags = _flags_save_string;
1828                 }
1829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1830                 if (_ptr_secdesc) {
1831                         NDR_PULL_ALLOC(ndr, r->secdesc);
1832                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1833                 } else {
1834                         r->secdesc = NULL;
1835                 }
1836                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1838                 if (r->priority > 99) {
1839                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1840                 }
1841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1844                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1847         }
1848         if (ndr_flags & NDR_BUFFERS) {
1849                 {
1850                         uint32_t _flags_save_string = ndr->flags;
1851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1852                         if (r->servername) {
1853                                 uint32_t _relative_save_offset;
1854                                 _relative_save_offset = ndr->offset;
1855                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1856                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1857                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1858                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1859                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1860                                 ndr->offset = _relative_save_offset;
1861                         }
1862                         ndr->flags = _flags_save_string;
1863                 }
1864                 {
1865                         uint32_t _flags_save_string = ndr->flags;
1866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1867                         if (r->printername) {
1868                                 uint32_t _relative_save_offset;
1869                                 _relative_save_offset = ndr->offset;
1870                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1871                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1872                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1873                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1874                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1875                                 ndr->offset = _relative_save_offset;
1876                         }
1877                         ndr->flags = _flags_save_string;
1878                 }
1879                 {
1880                         uint32_t _flags_save_string = ndr->flags;
1881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1882                         if (r->sharename) {
1883                                 uint32_t _relative_save_offset;
1884                                 _relative_save_offset = ndr->offset;
1885                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1886                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1887                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1888                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1889                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1890                                 ndr->offset = _relative_save_offset;
1891                         }
1892                         ndr->flags = _flags_save_string;
1893                 }
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         if (r->portname) {
1898                                 uint32_t _relative_save_offset;
1899                                 _relative_save_offset = ndr->offset;
1900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1901                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1902                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1905                                 ndr->offset = _relative_save_offset;
1906                         }
1907                         ndr->flags = _flags_save_string;
1908                 }
1909                 {
1910                         uint32_t _flags_save_string = ndr->flags;
1911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1912                         if (r->drivername) {
1913                                 uint32_t _relative_save_offset;
1914                                 _relative_save_offset = ndr->offset;
1915                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1916                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1917                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1918                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1919                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1920                                 ndr->offset = _relative_save_offset;
1921                         }
1922                         ndr->flags = _flags_save_string;
1923                 }
1924                 {
1925                         uint32_t _flags_save_string = ndr->flags;
1926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1927                         if (r->comment) {
1928                                 uint32_t _relative_save_offset;
1929                                 _relative_save_offset = ndr->offset;
1930                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1931                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1932                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1933                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1934                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1935                                 ndr->offset = _relative_save_offset;
1936                         }
1937                         ndr->flags = _flags_save_string;
1938                 }
1939                 {
1940                         uint32_t _flags_save_string = ndr->flags;
1941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1942                         if (r->location) {
1943                                 uint32_t _relative_save_offset;
1944                                 _relative_save_offset = ndr->offset;
1945                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1946                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1947                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1948                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1949                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1950                                 ndr->offset = _relative_save_offset;
1951                         }
1952                         ndr->flags = _flags_save_string;
1953                 }
1954                 if (r->devmode) {
1955                         uint32_t _relative_save_offset;
1956                         _relative_save_offset = ndr->offset;
1957                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1958                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1959                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1960                         {
1961                                 struct ndr_pull *_ndr_devmode;
1962                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1963                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1964                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1965                         }
1966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1967                         ndr->offset = _relative_save_offset;
1968                 }
1969                 {
1970                         uint32_t _flags_save_string = ndr->flags;
1971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1972                         if (r->sepfile) {
1973                                 uint32_t _relative_save_offset;
1974                                 _relative_save_offset = ndr->offset;
1975                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1976                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1977                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1978                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1979                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1980                                 ndr->offset = _relative_save_offset;
1981                         }
1982                         ndr->flags = _flags_save_string;
1983                 }
1984                 {
1985                         uint32_t _flags_save_string = ndr->flags;
1986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1987                         if (r->printprocessor) {
1988                                 uint32_t _relative_save_offset;
1989                                 _relative_save_offset = ndr->offset;
1990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1991                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1992                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1995                                 ndr->offset = _relative_save_offset;
1996                         }
1997                         ndr->flags = _flags_save_string;
1998                 }
1999                 {
2000                         uint32_t _flags_save_string = ndr->flags;
2001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2002                         if (r->datatype) {
2003                                 uint32_t _relative_save_offset;
2004                                 _relative_save_offset = ndr->offset;
2005                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2006                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2007                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2008                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2009                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2010                                 ndr->offset = _relative_save_offset;
2011                         }
2012                         ndr->flags = _flags_save_string;
2013                 }
2014                 {
2015                         uint32_t _flags_save_string = ndr->flags;
2016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2017                         if (r->parameters) {
2018                                 uint32_t _relative_save_offset;
2019                                 _relative_save_offset = ndr->offset;
2020                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2021                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2022                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2023                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2024                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2025                                 ndr->offset = _relative_save_offset;
2026                         }
2027                         ndr->flags = _flags_save_string;
2028                 }
2029                 if (r->secdesc) {
2030                         uint32_t _relative_save_offset;
2031                         _relative_save_offset = ndr->offset;
2032                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2033                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2034                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2035                         {
2036                                 struct ndr_pull *_ndr_secdesc;
2037                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2038                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2039                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2040                         }
2041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2042                         ndr->offset = _relative_save_offset;
2043                 }
2044         }
2045         return NDR_ERR_SUCCESS;
2046 }
2047
2048 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2049 {
2050         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2051         ndr->depth++;
2052         ndr_print_ptr(ndr, "servername", r->servername);
2053         ndr->depth++;
2054         if (r->servername) {
2055                 ndr_print_string(ndr, "servername", r->servername);
2056         }
2057         ndr->depth--;
2058         ndr_print_ptr(ndr, "printername", r->printername);
2059         ndr->depth++;
2060         if (r->printername) {
2061                 ndr_print_string(ndr, "printername", r->printername);
2062         }
2063         ndr->depth--;
2064         ndr_print_ptr(ndr, "sharename", r->sharename);
2065         ndr->depth++;
2066         if (r->sharename) {
2067                 ndr_print_string(ndr, "sharename", r->sharename);
2068         }
2069         ndr->depth--;
2070         ndr_print_ptr(ndr, "portname", r->portname);
2071         ndr->depth++;
2072         if (r->portname) {
2073                 ndr_print_string(ndr, "portname", r->portname);
2074         }
2075         ndr->depth--;
2076         ndr_print_ptr(ndr, "drivername", r->drivername);
2077         ndr->depth++;
2078         if (r->drivername) {
2079                 ndr_print_string(ndr, "drivername", r->drivername);
2080         }
2081         ndr->depth--;
2082         ndr_print_ptr(ndr, "comment", r->comment);
2083         ndr->depth++;
2084         if (r->comment) {
2085                 ndr_print_string(ndr, "comment", r->comment);
2086         }
2087         ndr->depth--;
2088         ndr_print_ptr(ndr, "location", r->location);
2089         ndr->depth++;
2090         if (r->location) {
2091                 ndr_print_string(ndr, "location", r->location);
2092         }
2093         ndr->depth--;
2094         ndr_print_ptr(ndr, "devmode", r->devmode);
2095         ndr->depth++;
2096         if (r->devmode) {
2097                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2098         }
2099         ndr->depth--;
2100         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2101         ndr->depth++;
2102         if (r->sepfile) {
2103                 ndr_print_string(ndr, "sepfile", r->sepfile);
2104         }
2105         ndr->depth--;
2106         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2107         ndr->depth++;
2108         if (r->printprocessor) {
2109                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2110         }
2111         ndr->depth--;
2112         ndr_print_ptr(ndr, "datatype", r->datatype);
2113         ndr->depth++;
2114         if (r->datatype) {
2115                 ndr_print_string(ndr, "datatype", r->datatype);
2116         }
2117         ndr->depth--;
2118         ndr_print_ptr(ndr, "parameters", r->parameters);
2119         ndr->depth++;
2120         if (r->parameters) {
2121                 ndr_print_string(ndr, "parameters", r->parameters);
2122         }
2123         ndr->depth--;
2124         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2125         ndr->depth++;
2126         if (r->secdesc) {
2127                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2128         }
2129         ndr->depth--;
2130         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2131         ndr_print_uint32(ndr, "priority", r->priority);
2132         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2133         ndr_print_uint32(ndr, "starttime", r->starttime);
2134         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2135         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2136         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2137         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2138         ndr->depth--;
2139 }
2140
2141 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2142 {
2143         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2144 }
2145
2146 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2147 {
2148         if (ndr_flags & NDR_SCALARS) {
2149                 NDR_CHECK(ndr_push_align(ndr, 5));
2150                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2151         }
2152         if (ndr_flags & NDR_BUFFERS) {
2153                 if (r->secdesc) {
2154                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
2155                         {
2156                                 struct ndr_push *_ndr_secdesc;
2157                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2158                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2159                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2160                         }
2161                 }
2162         }
2163         return NDR_ERR_SUCCESS;
2164 }
2165
2166 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2167 {
2168         uint32_t _ptr_secdesc;
2169         TALLOC_CTX *_mem_save_secdesc_0;
2170         if (ndr_flags & NDR_SCALARS) {
2171                 NDR_CHECK(ndr_pull_align(ndr, 5));
2172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2173                 if (_ptr_secdesc) {
2174                         NDR_PULL_ALLOC(ndr, r->secdesc);
2175                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2176                 } else {
2177                         r->secdesc = NULL;
2178                 }
2179         }
2180         if (ndr_flags & NDR_BUFFERS) {
2181                 if (r->secdesc) {
2182                         uint32_t _relative_save_offset;
2183                         _relative_save_offset = ndr->offset;
2184                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2185                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2186                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2187                         {
2188                                 struct ndr_pull *_ndr_secdesc;
2189                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2190                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2191                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2192                         }
2193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2194                         ndr->offset = _relative_save_offset;
2195                 }
2196         }
2197         return NDR_ERR_SUCCESS;
2198 }
2199
2200 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2201 {
2202         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2203         ndr->depth++;
2204         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2205         ndr->depth++;
2206         if (r->secdesc) {
2207                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2208         }
2209         ndr->depth--;
2210         ndr->depth--;
2211 }
2212
2213 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2214 {
2215         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2216 }
2217
2218 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2219 {
2220         if (ndr_flags & NDR_SCALARS) {
2221                 NDR_CHECK(ndr_push_align(ndr, 5));
2222                 {
2223                         uint32_t _flags_save_string = ndr->flags;
2224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2225                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2226                         ndr->flags = _flags_save_string;
2227                 }
2228                 {
2229                         uint32_t _flags_save_string = ndr->flags;
2230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2231                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2232                         ndr->flags = _flags_save_string;
2233                 }
2234                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2235         }
2236         if (ndr_flags & NDR_BUFFERS) {
2237                 {
2238                         uint32_t _flags_save_string = ndr->flags;
2239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2240                         if (r->printername) {
2241                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2242                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2243                         }
2244                         ndr->flags = _flags_save_string;
2245                 }
2246                 {
2247                         uint32_t _flags_save_string = ndr->flags;
2248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2249                         if (r->servername) {
2250                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
2251                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2252                         }
2253                         ndr->flags = _flags_save_string;
2254                 }
2255         }
2256         return NDR_ERR_SUCCESS;
2257 }
2258
2259 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2260 {
2261         uint32_t _ptr_printername;
2262         TALLOC_CTX *_mem_save_printername_0;
2263         uint32_t _ptr_servername;
2264         TALLOC_CTX *_mem_save_servername_0;
2265         if (ndr_flags & NDR_SCALARS) {
2266                 NDR_CHECK(ndr_pull_align(ndr, 5));
2267                 {
2268                         uint32_t _flags_save_string = ndr->flags;
2269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2270                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2271                         if (_ptr_printername) {
2272                                 NDR_PULL_ALLOC(ndr, r->printername);
2273                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2274                         } else {
2275                                 r->printername = NULL;
2276                         }
2277                         ndr->flags = _flags_save_string;
2278                 }
2279                 {
2280                         uint32_t _flags_save_string = ndr->flags;
2281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2282                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2283                         if (_ptr_servername) {
2284                                 NDR_PULL_ALLOC(ndr, r->servername);
2285                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2286                         } else {
2287                                 r->servername = NULL;
2288                         }
2289                         ndr->flags = _flags_save_string;
2290                 }
2291                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2292         }
2293         if (ndr_flags & NDR_BUFFERS) {
2294                 {
2295                         uint32_t _flags_save_string = ndr->flags;
2296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2297                         if (r->printername) {
2298                                 uint32_t _relative_save_offset;
2299                                 _relative_save_offset = ndr->offset;
2300                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2301                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2302                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2303                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2304                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2305                                 ndr->offset = _relative_save_offset;
2306                         }
2307                         ndr->flags = _flags_save_string;
2308                 }
2309                 {
2310                         uint32_t _flags_save_string = ndr->flags;
2311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2312                         if (r->servername) {
2313                                 uint32_t _relative_save_offset;
2314                                 _relative_save_offset = ndr->offset;
2315                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2316                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2317                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2318                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2319                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2320                                 ndr->offset = _relative_save_offset;
2321                         }
2322                         ndr->flags = _flags_save_string;
2323                 }
2324         }
2325         return NDR_ERR_SUCCESS;
2326 }
2327
2328 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2329 {
2330         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2331         ndr->depth++;
2332         ndr_print_ptr(ndr, "printername", r->printername);
2333         ndr->depth++;
2334         if (r->printername) {
2335                 ndr_print_string(ndr, "printername", r->printername);
2336         }
2337         ndr->depth--;
2338         ndr_print_ptr(ndr, "servername", r->servername);
2339         ndr->depth++;
2340         if (r->servername) {
2341                 ndr_print_string(ndr, "servername", r->servername);
2342         }
2343         ndr->depth--;
2344         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2345         ndr->depth--;
2346 }
2347
2348 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2349 {
2350         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2351 }
2352
2353 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2354 {
2355         if (ndr_flags & NDR_SCALARS) {
2356                 NDR_CHECK(ndr_push_align(ndr, 5));
2357                 {
2358                         uint32_t _flags_save_string = ndr->flags;
2359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2360                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2361                         ndr->flags = _flags_save_string;
2362                 }
2363                 {
2364                         uint32_t _flags_save_string = ndr->flags;
2365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2366                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2367                         ndr->flags = _flags_save_string;
2368                 }
2369                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2372         }
2373         if (ndr_flags & NDR_BUFFERS) {
2374                 {
2375                         uint32_t _flags_save_string = ndr->flags;
2376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2377                         if (r->printername) {
2378                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2379                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2380                         }
2381                         ndr->flags = _flags_save_string;
2382                 }
2383                 {
2384                         uint32_t _flags_save_string = ndr->flags;
2385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2386                         if (r->portname) {
2387                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
2388                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2389                         }
2390                         ndr->flags = _flags_save_string;
2391                 }
2392         }
2393         return NDR_ERR_SUCCESS;
2394 }
2395
2396 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2397 {
2398         uint32_t _ptr_printername;
2399         TALLOC_CTX *_mem_save_printername_0;
2400         uint32_t _ptr_portname;
2401         TALLOC_CTX *_mem_save_portname_0;
2402         if (ndr_flags & NDR_SCALARS) {
2403                 NDR_CHECK(ndr_pull_align(ndr, 5));
2404                 {
2405                         uint32_t _flags_save_string = ndr->flags;
2406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2407                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2408                         if (_ptr_printername) {
2409                                 NDR_PULL_ALLOC(ndr, r->printername);
2410                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2411                         } else {
2412                                 r->printername = NULL;
2413                         }
2414                         ndr->flags = _flags_save_string;
2415                 }
2416                 {
2417                         uint32_t _flags_save_string = ndr->flags;
2418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2419                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2420                         if (_ptr_portname) {
2421                                 NDR_PULL_ALLOC(ndr, r->portname);
2422                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2423                         } else {
2424                                 r->portname = NULL;
2425                         }
2426                         ndr->flags = _flags_save_string;
2427                 }
2428                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2431         }
2432         if (ndr_flags & NDR_BUFFERS) {
2433                 {
2434                         uint32_t _flags_save_string = ndr->flags;
2435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2436                         if (r->printername) {
2437                                 uint32_t _relative_save_offset;
2438                                 _relative_save_offset = ndr->offset;
2439                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2440                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2441                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2442                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2443                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2444                                 ndr->offset = _relative_save_offset;
2445                         }
2446                         ndr->flags = _flags_save_string;
2447                 }
2448                 {
2449                         uint32_t _flags_save_string = ndr->flags;
2450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2451                         if (r->portname) {
2452                                 uint32_t _relative_save_offset;
2453                                 _relative_save_offset = ndr->offset;
2454                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2455                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2456                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2457                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2458                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2459                                 ndr->offset = _relative_save_offset;
2460                         }
2461                         ndr->flags = _flags_save_string;
2462                 }
2463         }
2464         return NDR_ERR_SUCCESS;
2465 }
2466
2467 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2468 {
2469         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2470         ndr->depth++;
2471         ndr_print_ptr(ndr, "printername", r->printername);
2472         ndr->depth++;
2473         if (r->printername) {
2474                 ndr_print_string(ndr, "printername", r->printername);
2475         }
2476         ndr->depth--;
2477         ndr_print_ptr(ndr, "portname", r->portname);
2478         ndr->depth++;
2479         if (r->portname) {
2480                 ndr_print_string(ndr, "portname", r->portname);
2481         }
2482         ndr->depth--;
2483         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2484         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2485         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2486         ndr->depth--;
2487 }
2488
2489 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2490 {
2491         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2492 }
2493
2494 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2495 {
2496         if (ndr_flags & NDR_SCALARS) {
2497                 NDR_CHECK(ndr_push_align(ndr, 4));
2498                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2499         }
2500         if (ndr_flags & NDR_BUFFERS) {
2501         }
2502         return NDR_ERR_SUCCESS;
2503 }
2504
2505 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2506 {
2507         if (ndr_flags & NDR_SCALARS) {
2508                 NDR_CHECK(ndr_pull_align(ndr, 4));
2509                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2510         }
2511         if (ndr_flags & NDR_BUFFERS) {
2512         }
2513         return NDR_ERR_SUCCESS;
2514 }
2515
2516 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2517 {
2518         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2519         ndr->depth++;
2520         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2521         ndr->depth--;
2522 }
2523
2524 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2525 {
2526         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2527 }
2528
2529 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2530 {
2531         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2532         return NDR_ERR_SUCCESS;
2533 }
2534
2535 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2536 {
2537         uint32_t v;
2538         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2539         *r = v;
2540         return NDR_ERR_SUCCESS;
2541 }
2542
2543 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2544 {
2545         ndr_print_uint32(ndr, name, r);
2546         ndr->depth++;
2547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2552         ndr->depth--;
2553 }
2554
2555 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2556 {
2557         if (ndr_flags & NDR_SCALARS) {
2558                 NDR_CHECK(ndr_push_align(ndr, 5));
2559                 {
2560                         uint32_t _flags_save_string = ndr->flags;
2561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2562                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2563                         ndr->flags = _flags_save_string;
2564                 }
2565                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2566         }
2567         if (ndr_flags & NDR_BUFFERS) {
2568                 {
2569                         uint32_t _flags_save_string = ndr->flags;
2570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2571                         if (r->guid) {
2572                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2573                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2574                         }
2575                         ndr->flags = _flags_save_string;
2576                 }
2577         }
2578         return NDR_ERR_SUCCESS;
2579 }
2580
2581 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2582 {
2583         uint32_t _ptr_guid;
2584         TALLOC_CTX *_mem_save_guid_0;
2585         if (ndr_flags & NDR_SCALARS) {
2586                 NDR_CHECK(ndr_pull_align(ndr, 5));
2587                 {
2588                         uint32_t _flags_save_string = ndr->flags;
2589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2590                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2591                         if (_ptr_guid) {
2592                                 NDR_PULL_ALLOC(ndr, r->guid);
2593                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2594                         } else {
2595                                 r->guid = NULL;
2596                         }
2597                         ndr->flags = _flags_save_string;
2598                 }
2599                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2600         }
2601         if (ndr_flags & NDR_BUFFERS) {
2602                 {
2603                         uint32_t _flags_save_string = ndr->flags;
2604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2605                         if (r->guid) {
2606                                 uint32_t _relative_save_offset;
2607                                 _relative_save_offset = ndr->offset;
2608                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2609                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2610                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2613                                 ndr->offset = _relative_save_offset;
2614                         }
2615                         ndr->flags = _flags_save_string;
2616                 }
2617         }
2618         return NDR_ERR_SUCCESS;
2619 }
2620
2621 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2622 {
2623         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2624         ndr->depth++;
2625         ndr_print_ptr(ndr, "guid", r->guid);
2626         ndr->depth++;
2627         if (r->guid) {
2628                 ndr_print_string(ndr, "guid", r->guid);
2629         }
2630         ndr->depth--;
2631         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2632         ndr->depth--;
2633 }
2634
2635 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2636 {
2637         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2638 }
2639
2640 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2641 {
2642         if (ndr_flags & NDR_SCALARS) {
2643                 NDR_CHECK(ndr_push_align(ndr, 5));
2644                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2645         }
2646         if (ndr_flags & NDR_BUFFERS) {
2647                 if (r->devmode) {
2648                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2649                         {
2650                                 struct ndr_push *_ndr_devmode;
2651                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2652                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2653                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2654                         }
2655                 }
2656         }
2657         return NDR_ERR_SUCCESS;
2658 }
2659
2660 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2661 {
2662         uint32_t _ptr_devmode;
2663         TALLOC_CTX *_mem_save_devmode_0;
2664         if (ndr_flags & NDR_SCALARS) {
2665                 NDR_CHECK(ndr_pull_align(ndr, 5));
2666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2667                 if (_ptr_devmode) {
2668                         NDR_PULL_ALLOC(ndr, r->devmode);
2669                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2670                 } else {
2671                         r->devmode = NULL;
2672                 }
2673         }
2674         if (ndr_flags & NDR_BUFFERS) {
2675                 if (r->devmode) {
2676                         uint32_t _relative_save_offset;
2677                         _relative_save_offset = ndr->offset;
2678                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2679                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2680                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2681                         {
2682                                 struct ndr_pull *_ndr_devmode;
2683                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2684                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2685                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2686                         }
2687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2688                         ndr->offset = _relative_save_offset;
2689                 }
2690         }
2691         return NDR_ERR_SUCCESS;
2692 }
2693
2694 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2695 {
2696         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2697         ndr->depth++;
2698         ndr_print_ptr(ndr, "devmode", r->devmode);
2699         ndr->depth++;
2700         if (r->devmode) {
2701                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2702         }
2703         ndr->depth--;
2704         ndr->depth--;
2705 }
2706
2707 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2708 {
2709         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2710         if (ndr_flags & NDR_SCALARS) {
2711                 int level = ndr_push_get_switch_value(ndr, r);
2712                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2713                 switch (level) {
2714                         case 0: {
2715                                 NDR_CHECK(ndr_push_align(ndr, 5));
2716                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2717                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2718                         break; }
2719
2720                         case 1: {
2721                                 NDR_CHECK(ndr_push_align(ndr, 5));
2722                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2723                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2724                         break; }
2725
2726                         case 2: {
2727                                 NDR_CHECK(ndr_push_align(ndr, 5));
2728                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2729                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2730                         break; }
2731
2732                         case 3: {
2733                                 NDR_CHECK(ndr_push_align(ndr, 5));
2734                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2735                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2736                         break; }
2737
2738                         case 4: {
2739                                 NDR_CHECK(ndr_push_align(ndr, 5));
2740                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2741                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2742                         break; }
2743
2744                         case 5: {
2745                                 NDR_CHECK(ndr_push_align(ndr, 5));
2746                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2747                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2748                         break; }
2749
2750                         case 6: {
2751                                 NDR_CHECK(ndr_push_align(ndr, 4));
2752                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2753                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2754                         break; }
2755
2756                         case 7: {
2757                                 NDR_CHECK(ndr_push_align(ndr, 5));
2758                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2759                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2760                         break; }
2761
2762                         case 8: {
2763                                 NDR_CHECK(ndr_push_align(ndr, 5));
2764                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2765                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2766                         break; }
2767
2768                         case 9: {
2769                                 NDR_CHECK(ndr_push_align(ndr, 5));
2770                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2771                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2772                         break; }
2773
2774                         default: {
2775                         break; }
2776
2777                 }
2778         }
2779         if (ndr_flags & NDR_BUFFERS) {
2780                 int level = ndr_push_get_switch_value(ndr, r);
2781                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2782                 switch (level) {
2783                         case 0:
2784                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2785                         break;
2786
2787                         case 1:
2788                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2789                         break;
2790
2791                         case 2:
2792                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2793                         break;
2794
2795                         case 3:
2796                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2797                         break;
2798
2799                         case 4:
2800                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2801                         break;
2802
2803                         case 5:
2804                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2805                         break;
2806
2807                         case 6:
2808                         break;
2809
2810                         case 7:
2811                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2812                         break;
2813
2814                         case 8:
2815                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2816                         break;
2817
2818                         case 9:
2819                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2820                         break;
2821
2822                         default:
2823                         break;
2824
2825                 }
2826         }
2827         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2828         return NDR_ERR_SUCCESS;
2829 }
2830
2831 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2832 {
2833         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2834         int level;
2835         level = ndr_pull_get_switch_value(ndr, r);
2836         if (ndr_flags & NDR_SCALARS) {
2837                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2838                 switch (level) {
2839                         case 0: {
2840                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2841                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2842                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2843                         break; }
2844
2845                         case 1: {
2846                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2847                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2848                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2849                         break; }
2850
2851                         case 2: {
2852                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2853                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2854                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2855                         break; }
2856
2857                         case 3: {
2858                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2859                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2860                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2861                         break; }
2862
2863                         case 4: {
2864                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2865                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2866                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2867                         break; }
2868
2869                         case 5: {
2870                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2871                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2872                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2873                         break; }
2874
2875                         case 6: {
2876                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2877                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2878                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2879                         break; }
2880
2881                         case 7: {
2882                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2883                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2884                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2885                         break; }
2886
2887                         case 8: {
2888                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2889                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2890                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2891                         break; }
2892
2893                         case 9: {
2894                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2895                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2896                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2897                         break; }
2898
2899                         default: {
2900                         break; }
2901
2902                 }
2903         }
2904         if (ndr_flags & NDR_BUFFERS) {
2905                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2906                 switch (level) {
2907                         case 0:
2908                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2909                         break;
2910
2911                         case 1:
2912                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2913                         break;
2914
2915                         case 2:
2916                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2917                         break;
2918
2919                         case 3:
2920                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2921                         break;
2922
2923                         case 4:
2924                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2925                         break;
2926
2927                         case 5:
2928                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2929                         break;
2930
2931                         case 6:
2932                         break;
2933
2934                         case 7:
2935                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2936                         break;
2937
2938                         case 8:
2939                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2940                         break;
2941
2942                         case 9:
2943                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2944                         break;
2945
2946                         default:
2947                         break;
2948
2949                 }
2950         }
2951         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2952         return NDR_ERR_SUCCESS;
2953 }
2954
2955 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2956 {
2957         int level;
2958         level = ndr_print_get_switch_value(ndr, r);
2959         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2960         switch (level) {
2961                 case 0:
2962                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2963                 break;
2964
2965                 case 1:
2966                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2967                 break;
2968
2969                 case 2:
2970                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2971                 break;
2972
2973                 case 3:
2974                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2975                 break;
2976
2977                 case 4:
2978                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2979                 break;
2980
2981                 case 5:
2982                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2983                 break;
2984
2985                 case 6:
2986                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2987                 break;
2988
2989                 case 7:
2990                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2991                 break;
2992
2993                 case 8:
2994                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2995                 break;
2996
2997                 case 9:
2998                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2999                 break;
3000
3001                 default:
3002                 break;
3003
3004         }
3005 }
3006
3007 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3008 {
3009         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3010 }
3011
3012 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3013 {
3014         if (ndr_flags & NDR_SCALARS) {
3015                 NDR_CHECK(ndr_push_align(ndr, 5));
3016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3018         }
3019         if (ndr_flags & NDR_BUFFERS) {
3020                 if (r->devmode) {
3021                         {
3022                                 struct ndr_push *_ndr_devmode;
3023                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3024                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3025                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3026                         }
3027                 }
3028         }
3029         return NDR_ERR_SUCCESS;
3030 }
3031
3032 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3033 {
3034         uint32_t _ptr_devmode;
3035         TALLOC_CTX *_mem_save_devmode_0;
3036         if (ndr_flags & NDR_SCALARS) {
3037                 NDR_CHECK(ndr_pull_align(ndr, 5));
3038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3040                 if (_ptr_devmode) {
3041                         NDR_PULL_ALLOC(ndr, r->devmode);
3042                 } else {
3043                         r->devmode = NULL;
3044                 }
3045         }
3046         if (ndr_flags & NDR_BUFFERS) {
3047                 if (r->devmode) {
3048                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3049                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3050                         {
3051                                 struct ndr_pull *_ndr_devmode;
3052                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3053                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3054                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3055                         }
3056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3057                 }
3058         }
3059         return NDR_ERR_SUCCESS;
3060 }
3061
3062 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3063 {
3064         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3065         ndr->depth++;
3066         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);
3067         ndr_print_ptr(ndr, "devmode", r->devmode);
3068         ndr->depth++;
3069         if (r->devmode) {
3070                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3071         }
3072         ndr->depth--;
3073         ndr->depth--;
3074 }
3075
3076 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3077 {
3078         if (ndr_flags & NDR_SCALARS) {
3079                 NDR_CHECK(ndr_push_align(ndr, 5));
3080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3081                 {
3082                         uint32_t _flags_save_string = ndr->flags;
3083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3084                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3085                         ndr->flags = _flags_save_string;
3086                 }
3087                 {
3088                         uint32_t _flags_save_string = ndr->flags;
3089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3090                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3091                         ndr->flags = _flags_save_string;
3092                 }
3093                 {
3094                         uint32_t _flags_save_string = ndr->flags;
3095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3096                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3097                         ndr->flags = _flags_save_string;
3098                 }
3099                 {
3100                         uint32_t _flags_save_string = ndr->flags;
3101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3102                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3103                         ndr->flags = _flags_save_string;
3104                 }
3105                 {
3106                         uint32_t _flags_save_string = ndr->flags;
3107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3108                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3109                         ndr->flags = _flags_save_string;
3110                 }
3111                 {
3112                         uint32_t _flags_save_string = ndr->flags;
3113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3114                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3115                         ndr->flags = _flags_save_string;
3116                 }
3117                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3122                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3123         }
3124         if (ndr_flags & NDR_BUFFERS) {
3125                 {
3126                         uint32_t _flags_save_string = ndr->flags;
3127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3128                         if (r->printer_name) {
3129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3131                         }
3132                         ndr->flags = _flags_save_string;
3133                 }
3134                 {
3135                         uint32_t _flags_save_string = ndr->flags;
3136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3137                         if (r->server_name) {
3138                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3139                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3140                         }
3141                         ndr->flags = _flags_save_string;
3142                 }
3143                 {
3144                         uint32_t _flags_save_string = ndr->flags;
3145                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3146                         if (r->user_name) {
3147                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3148                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3149                         }
3150                         ndr->flags = _flags_save_string;
3151                 }
3152                 {
3153                         uint32_t _flags_save_string = ndr->flags;
3154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3155                         if (r->document_name) {
3156                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3157                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3158                         }
3159                         ndr->flags = _flags_save_string;
3160                 }
3161                 {
3162                         uint32_t _flags_save_string = ndr->flags;
3163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3164                         if (r->data_type) {
3165                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3166                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3167                         }
3168                         ndr->flags = _flags_save_string;
3169                 }
3170                 {
3171                         uint32_t _flags_save_string = ndr->flags;
3172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3173                         if (r->text_status) {
3174                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3175                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3176                         }
3177                         ndr->flags = _flags_save_string;
3178                 }
3179         }
3180         return NDR_ERR_SUCCESS;
3181 }
3182
3183 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3184 {
3185         uint32_t _ptr_printer_name;
3186         TALLOC_CTX *_mem_save_printer_name_0;
3187         uint32_t _ptr_server_name;
3188         TALLOC_CTX *_mem_save_server_name_0;
3189         uint32_t _ptr_user_name;
3190         TALLOC_CTX *_mem_save_user_name_0;
3191         uint32_t _ptr_document_name;
3192         TALLOC_CTX *_mem_save_document_name_0;
3193         uint32_t _ptr_data_type;
3194         TALLOC_CTX *_mem_save_data_type_0;
3195         uint32_t _ptr_text_status;
3196         TALLOC_CTX *_mem_save_text_status_0;
3197         if (ndr_flags & NDR_SCALARS) {
3198                 NDR_CHECK(ndr_pull_align(ndr, 5));
3199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3200                 {
3201                         uint32_t _flags_save_string = ndr->flags;
3202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3203                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3204                         if (_ptr_printer_name) {
3205                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3206                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3207                         } else {
3208                                 r->printer_name = NULL;
3209                         }
3210                         ndr->flags = _flags_save_string;
3211                 }
3212                 {
3213                         uint32_t _flags_save_string = ndr->flags;
3214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3215                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3216                         if (_ptr_server_name) {
3217                                 NDR_PULL_ALLOC(ndr, r->server_name);
3218                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3219                         } else {
3220                                 r->server_name = NULL;
3221                         }
3222                         ndr->flags = _flags_save_string;
3223                 }
3224                 {
3225                         uint32_t _flags_save_string = ndr->flags;
3226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3227                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3228                         if (_ptr_user_name) {
3229                                 NDR_PULL_ALLOC(ndr, r->user_name);
3230                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3231                         } else {
3232                                 r->user_name = NULL;
3233                         }
3234                         ndr->flags = _flags_save_string;
3235                 }
3236                 {
3237                         uint32_t _flags_save_string = ndr->flags;
3238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3239                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3240                         if (_ptr_document_name) {
3241                                 NDR_PULL_ALLOC(ndr, r->document_name);
3242                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3243                         } else {
3244                                 r->document_name = NULL;
3245                         }
3246                         ndr->flags = _flags_save_string;
3247                 }
3248                 {
3249                         uint32_t _flags_save_string = ndr->flags;
3250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3251                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3252                         if (_ptr_data_type) {
3253                                 NDR_PULL_ALLOC(ndr, r->data_type);
3254                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3255                         } else {
3256                                 r->data_type = NULL;
3257                         }
3258                         ndr->flags = _flags_save_string;
3259                 }
3260                 {
3261                         uint32_t _flags_save_string = ndr->flags;
3262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3263                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3264                         if (_ptr_text_status) {
3265                                 NDR_PULL_ALLOC(ndr, r->text_status);
3266                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3267                         } else {
3268                                 r->text_status = NULL;
3269                         }
3270                         ndr->flags = _flags_save_string;
3271                 }
3272                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3274                 if (r->priority > 99) {
3275                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3276                 }
3277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3280                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3281         }
3282         if (ndr_flags & NDR_BUFFERS) {
3283                 {
3284                         uint32_t _flags_save_string = ndr->flags;
3285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3286                         if (r->printer_name) {
3287                                 uint32_t _relative_save_offset;
3288                                 _relative_save_offset = ndr->offset;
3289                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3290                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3291                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3292                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3293                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3294                                 ndr->offset = _relative_save_offset;
3295                         }
3296                         ndr->flags = _flags_save_string;
3297                 }
3298                 {
3299                         uint32_t _flags_save_string = ndr->flags;
3300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3301                         if (r->server_name) {
3302                                 uint32_t _relative_save_offset;
3303                                 _relative_save_offset = ndr->offset;
3304                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3305                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3306                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3307                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3308                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3309                                 ndr->offset = _relative_save_offset;
3310                         }
3311                         ndr->flags = _flags_save_string;
3312                 }
3313                 {
3314                         uint32_t _flags_save_string = ndr->flags;
3315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3316                         if (r->user_name) {
3317                                 uint32_t _relative_save_offset;
3318                                 _relative_save_offset = ndr->offset;
3319                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3320                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3321                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3322                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3323                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3324                                 ndr->offset = _relative_save_offset;
3325                         }
3326                         ndr->flags = _flags_save_string;
3327                 }
3328                 {
3329                         uint32_t _flags_save_string = ndr->flags;
3330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3331                         if (r->document_name) {
3332                                 uint32_t _relative_save_offset;
3333                                 _relative_save_offset = ndr->offset;
3334                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3335                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3336                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3337                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3338                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3339                                 ndr->offset = _relative_save_offset;
3340                         }
3341                         ndr->flags = _flags_save_string;
3342                 }
3343                 {
3344                         uint32_t _flags_save_string = ndr->flags;
3345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3346                         if (r->data_type) {
3347                                 uint32_t _relative_save_offset;
3348                                 _relative_save_offset = ndr->offset;
3349                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3350                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3351                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3352                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3353                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3354                                 ndr->offset = _relative_save_offset;
3355                         }
3356                         ndr->flags = _flags_save_string;
3357                 }
3358                 {
3359                         uint32_t _flags_save_string = ndr->flags;
3360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3361                         if (r->text_status) {
3362                                 uint32_t _relative_save_offset;
3363                                 _relative_save_offset = ndr->offset;
3364                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3365                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3366                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3367                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3368                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3369                                 ndr->offset = _relative_save_offset;
3370                         }
3371                         ndr->flags = _flags_save_string;
3372                 }
3373         }
3374         return NDR_ERR_SUCCESS;
3375 }
3376
3377 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3378 {
3379         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3380         ndr->depth++;
3381         ndr_print_uint32(ndr, "job_id", r->job_id);
3382         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3383         ndr->depth++;
3384         if (r->printer_name) {
3385                 ndr_print_string(ndr, "printer_name", r->printer_name);
3386         }
3387         ndr->depth--;
3388         ndr_print_ptr(ndr, "server_name", r->server_name);
3389         ndr->depth++;
3390         if (r->server_name) {
3391                 ndr_print_string(ndr, "server_name", r->server_name);
3392         }
3393         ndr->depth--;
3394         ndr_print_ptr(ndr, "user_name", r->user_name);
3395         ndr->depth++;
3396         if (r->user_name) {
3397                 ndr_print_string(ndr, "user_name", r->user_name);
3398         }
3399         ndr->depth--;
3400         ndr_print_ptr(ndr, "document_name", r->document_name);
3401         ndr->depth++;
3402         if (r->document_name) {
3403                 ndr_print_string(ndr, "document_name", r->document_name);
3404         }
3405         ndr->depth--;
3406         ndr_print_ptr(ndr, "data_type", r->data_type);
3407         ndr->depth++;
3408         if (r->data_type) {
3409                 ndr_print_string(ndr, "data_type", r->data_type);
3410         }
3411         ndr->depth--;
3412         ndr_print_ptr(ndr, "text_status", r->text_status);
3413         ndr->depth++;
3414         if (r->text_status) {
3415                 ndr_print_string(ndr, "text_status", r->text_status);
3416         }
3417         ndr->depth--;
3418         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3419         ndr_print_uint32(ndr, "priority", r->priority);
3420         ndr_print_uint32(ndr, "position", r->position);
3421         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3422         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3423         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3424         ndr->depth--;
3425 }
3426
3427 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3428 {
3429         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3430 }
3431
3432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3433 {
3434         if (ndr_flags & NDR_SCALARS) {
3435                 NDR_CHECK(ndr_push_align(ndr, 5));
3436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3437                 {
3438                         uint32_t _flags_save_string = ndr->flags;
3439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3440                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3441                         ndr->flags = _flags_save_string;
3442                 }
3443                 {
3444                         uint32_t _flags_save_string = ndr->flags;
3445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3446                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3447                         ndr->flags = _flags_save_string;
3448                 }
3449                 {
3450                         uint32_t _flags_save_string = ndr->flags;
3451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3452                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3453                         ndr->flags = _flags_save_string;
3454                 }
3455                 {
3456                         uint32_t _flags_save_string = ndr->flags;
3457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3458                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3459                         ndr->flags = _flags_save_string;
3460                 }
3461                 {
3462                         uint32_t _flags_save_string = ndr->flags;
3463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3464                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3465                         ndr->flags = _flags_save_string;
3466                 }
3467                 {
3468                         uint32_t _flags_save_string = ndr->flags;
3469                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3470                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3471                         ndr->flags = _flags_save_string;
3472                 }
3473                 {
3474                         uint32_t _flags_save_string = ndr->flags;
3475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3476                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3477                         ndr->flags = _flags_save_string;
3478                 }
3479                 {
3480                         uint32_t _flags_save_string = ndr->flags;
3481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3482                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3483                         ndr->flags = _flags_save_string;
3484                 }
3485                 {
3486                         uint32_t _flags_save_string = ndr->flags;
3487                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3488                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3489                         ndr->flags = _flags_save_string;
3490                 }
3491                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3492                 {
3493                         uint32_t _flags_save_string = ndr->flags;
3494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3495                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3496                         ndr->flags = _flags_save_string;
3497                 }
3498                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3499                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3506                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3509         }
3510         if (ndr_flags & NDR_BUFFERS) {
3511                 {
3512                         uint32_t _flags_save_string = ndr->flags;
3513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3514                         if (r->printer_name) {
3515                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3516                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3517                         }
3518                         ndr->flags = _flags_save_string;
3519                 }
3520                 {
3521                         uint32_t _flags_save_string = ndr->flags;
3522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3523                         if (r->server_name) {
3524                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3525                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3526                         }
3527                         ndr->flags = _flags_save_string;
3528                 }
3529                 {
3530                         uint32_t _flags_save_string = ndr->flags;
3531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3532                         if (r->user_name) {
3533                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3534                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3535                         }
3536                         ndr->flags = _flags_save_string;
3537                 }
3538                 {
3539                         uint32_t _flags_save_string = ndr->flags;
3540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3541                         if (r->document_name) {
3542                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3543                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3544                         }
3545                         ndr->flags = _flags_save_string;
3546                 }
3547                 {
3548                         uint32_t _flags_save_string = ndr->flags;
3549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3550                         if (r->notify_name) {
3551                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3552                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3553                         }
3554                         ndr->flags = _flags_save_string;
3555                 }
3556                 {
3557                         uint32_t _flags_save_string = ndr->flags;
3558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3559                         if (r->data_type) {
3560                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3561                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3562                         }
3563                         ndr->flags = _flags_save_string;
3564                 }
3565                 {
3566                         uint32_t _flags_save_string = ndr->flags;
3567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3568                         if (r->print_processor) {
3569                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3570                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3571                         }
3572                         ndr->flags = _flags_save_string;
3573                 }
3574                 {
3575                         uint32_t _flags_save_string = ndr->flags;
3576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3577                         if (r->parameters) {
3578                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3579                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3580                         }
3581                         ndr->flags = _flags_save_string;
3582                 }
3583                 {
3584                         uint32_t _flags_save_string = ndr->flags;
3585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3586                         if (r->driver_name) {
3587                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3588                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3589                         }
3590                         ndr->flags = _flags_save_string;
3591                 }
3592                 if (r->devmode) {
3593                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3594                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3595                 }
3596                 {
3597                         uint32_t _flags_save_string = ndr->flags;
3598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3599                         if (r->text_status) {
3600                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3601                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3602                         }
3603                         ndr->flags = _flags_save_string;
3604                 }
3605                 if (r->secdesc) {
3606                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3607                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3608                 }
3609         }
3610         return NDR_ERR_SUCCESS;
3611 }
3612
3613 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3614 {
3615         uint32_t _ptr_printer_name;
3616         TALLOC_CTX *_mem_save_printer_name_0;
3617         uint32_t _ptr_server_name;
3618         TALLOC_CTX *_mem_save_server_name_0;
3619         uint32_t _ptr_user_name;
3620         TALLOC_CTX *_mem_save_user_name_0;
3621         uint32_t _ptr_document_name;
3622         TALLOC_CTX *_mem_save_document_name_0;
3623         uint32_t _ptr_notify_name;
3624         TALLOC_CTX *_mem_save_notify_name_0;
3625         uint32_t _ptr_data_type;
3626         TALLOC_CTX *_mem_save_data_type_0;
3627         uint32_t _ptr_print_processor;
3628         TALLOC_CTX *_mem_save_print_processor_0;
3629         uint32_t _ptr_parameters;
3630         TALLOC_CTX *_mem_save_parameters_0;
3631         uint32_t _ptr_driver_name;
3632         TALLOC_CTX *_mem_save_driver_name_0;
3633         uint32_t _ptr_devmode;
3634         TALLOC_CTX *_mem_save_devmode_0;
3635         uint32_t _ptr_text_status;
3636         TALLOC_CTX *_mem_save_text_status_0;
3637         uint32_t _ptr_secdesc;
3638         TALLOC_CTX *_mem_save_secdesc_0;
3639         if (ndr_flags & NDR_SCALARS) {
3640                 NDR_CHECK(ndr_pull_align(ndr, 5));
3641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3642                 {
3643                         uint32_t _flags_save_string = ndr->flags;
3644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3645                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3646                         if (_ptr_printer_name) {
3647                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3648                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3649                         } else {
3650                                 r->printer_name = NULL;
3651                         }
3652                         ndr->flags = _flags_save_string;
3653                 }
3654                 {
3655                         uint32_t _flags_save_string = ndr->flags;
3656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3657                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3658                         if (_ptr_server_name) {
3659                                 NDR_PULL_ALLOC(ndr, r->server_name);
3660                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3661                         } else {
3662                                 r->server_name = NULL;
3663                         }
3664                         ndr->flags = _flags_save_string;
3665                 }
3666                 {
3667                         uint32_t _flags_save_string = ndr->flags;
3668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3669                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3670                         if (_ptr_user_name) {
3671                                 NDR_PULL_ALLOC(ndr, r->user_name);
3672                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3673                         } else {
3674                                 r->user_name = NULL;
3675                         }
3676                         ndr->flags = _flags_save_string;
3677                 }
3678                 {
3679                         uint32_t _flags_save_string = ndr->flags;
3680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3681                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3682                         if (_ptr_document_name) {
3683                                 NDR_PULL_ALLOC(ndr, r->document_name);
3684                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3685                         } else {
3686                                 r->document_name = NULL;
3687                         }
3688                         ndr->flags = _flags_save_string;
3689                 }
3690                 {
3691                         uint32_t _flags_save_string = ndr->flags;
3692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3694                         if (_ptr_notify_name) {
3695                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3697                         } else {
3698                                 r->notify_name = NULL;
3699                         }
3700                         ndr->flags = _flags_save_string;
3701                 }
3702                 {
3703                         uint32_t _flags_save_string = ndr->flags;
3704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3706                         if (_ptr_data_type) {
3707                                 NDR_PULL_ALLOC(ndr, r->data_type);
3708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3709                         } else {
3710                                 r->data_type = NULL;
3711                         }
3712                         ndr->flags = _flags_save_string;
3713                 }
3714                 {
3715                         uint32_t _flags_save_string = ndr->flags;
3716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3718                         if (_ptr_print_processor) {
3719                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3721                         } else {
3722                                 r->print_processor = NULL;
3723                         }
3724                         ndr->flags = _flags_save_string;
3725                 }
3726                 {
3727                         uint32_t _flags_save_string = ndr->flags;
3728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3730                         if (_ptr_parameters) {
3731                                 NDR_PULL_ALLOC(ndr, r->parameters);
3732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3733                         } else {
3734                                 r->parameters = NULL;
3735                         }
3736                         ndr->flags = _flags_save_string;
3737                 }
3738                 {
3739                         uint32_t _flags_save_string = ndr->flags;
3740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3742                         if (_ptr_driver_name) {
3743                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3745                         } else {
3746                                 r->driver_name = NULL;
3747                         }
3748                         ndr->flags = _flags_save_string;
3749                 }
3750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3751                 if (_ptr_devmode) {
3752                         NDR_PULL_ALLOC(ndr, r->devmode);
3753                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3754                 } else {
3755                         r->devmode = NULL;
3756                 }
3757                 {
3758                         uint32_t _flags_save_string = ndr->flags;
3759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3760                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3761                         if (_ptr_text_status) {
3762                                 NDR_PULL_ALLOC(ndr, r->text_status);
3763                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3764                         } else {
3765                                 r->text_status = NULL;
3766                         }
3767                         ndr->flags = _flags_save_string;
3768                 }
3769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3770                 if (_ptr_secdesc) {
3771                         NDR_PULL_ALLOC(ndr, r->secdesc);
3772                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3773                 } else {
3774                         r->secdesc = NULL;
3775                 }
3776                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3778                 if (r->priority > 99) {
3779                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3780                 }
3781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3786                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3789         }
3790         if (ndr_flags & NDR_BUFFERS) {
3791                 {
3792                         uint32_t _flags_save_string = ndr->flags;
3793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3794                         if (r->printer_name) {
3795                                 uint32_t _relative_save_offset;
3796                                 _relative_save_offset = ndr->offset;
3797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3798                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3799                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3802                                 ndr->offset = _relative_save_offset;
3803                         }
3804                         ndr->flags = _flags_save_string;
3805                 }
3806                 {
3807                         uint32_t _flags_save_string = ndr->flags;
3808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3809                         if (r->server_name) {
3810                                 uint32_t _relative_save_offset;
3811                                 _relative_save_offset = ndr->offset;
3812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3813                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3814                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3817                                 ndr->offset = _relative_save_offset;
3818                         }
3819                         ndr->flags = _flags_save_string;
3820                 }
3821                 {
3822                         uint32_t _flags_save_string = ndr->flags;
3823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3824                         if (r->user_name) {
3825                                 uint32_t _relative_save_offset;
3826                                 _relative_save_offset = ndr->offset;
3827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3828                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3829                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3832                                 ndr->offset = _relative_save_offset;
3833                         }
3834                         ndr->flags = _flags_save_string;
3835                 }
3836                 {
3837                         uint32_t _flags_save_string = ndr->flags;
3838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3839                         if (r->document_name) {
3840                                 uint32_t _relative_save_offset;
3841                                 _relative_save_offset = ndr->offset;
3842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3843                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3844                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3847                                 ndr->offset = _relative_save_offset;
3848                         }
3849                         ndr->flags = _flags_save_string;
3850                 }
3851                 {
3852                         uint32_t _flags_save_string = ndr->flags;
3853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3854                         if (r->notify_name) {
3855                                 uint32_t _relative_save_offset;
3856                                 _relative_save_offset = ndr->offset;
3857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3858                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3859                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3862                                 ndr->offset = _relative_save_offset;
3863                         }
3864                         ndr->flags = _flags_save_string;
3865                 }
3866                 {
3867                         uint32_t _flags_save_string = ndr->flags;
3868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3869                         if (r->data_type) {
3870                                 uint32_t _relative_save_offset;
3871                                 _relative_save_offset = ndr->offset;
3872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3873                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3874                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3877                                 ndr->offset = _relative_save_offset;
3878                         }
3879                         ndr->flags = _flags_save_string;
3880                 }
3881                 {
3882                         uint32_t _flags_save_string = ndr->flags;
3883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3884                         if (r->print_processor) {
3885                                 uint32_t _relative_save_offset;
3886                                 _relative_save_offset = ndr->offset;
3887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3888                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3889                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3892                                 ndr->offset = _relative_save_offset;
3893                         }
3894                         ndr->flags = _flags_save_string;
3895                 }
3896                 {
3897                         uint32_t _flags_save_string = ndr->flags;
3898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3899                         if (r->parameters) {
3900                                 uint32_t _relative_save_offset;
3901                                 _relative_save_offset = ndr->offset;
3902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3903                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3904                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3907                                 ndr->offset = _relative_save_offset;
3908                         }
3909                         ndr->flags = _flags_save_string;
3910                 }
3911                 {
3912                         uint32_t _flags_save_string = ndr->flags;
3913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3914                         if (r->driver_name) {
3915                                 uint32_t _relative_save_offset;
3916                                 _relative_save_offset = ndr->offset;
3917                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3918                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3919                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3920                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3921                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3922                                 ndr->offset = _relative_save_offset;
3923                         }
3924                         ndr->flags = _flags_save_string;
3925                 }
3926                 if (r->devmode) {
3927                         uint32_t _relative_save_offset;
3928                         _relative_save_offset = ndr->offset;
3929                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3930                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3931                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3932                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3934                         ndr->offset = _relative_save_offset;
3935                 }
3936                 {
3937                         uint32_t _flags_save_string = ndr->flags;
3938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3939                         if (r->text_status) {
3940                                 uint32_t _relative_save_offset;
3941                                 _relative_save_offset = ndr->offset;
3942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3943                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3944                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3947                                 ndr->offset = _relative_save_offset;
3948                         }
3949                         ndr->flags = _flags_save_string;
3950                 }
3951                 if (r->secdesc) {
3952                         uint32_t _relative_save_offset;
3953                         _relative_save_offset = ndr->offset;
3954                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3955                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3956                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3957                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3959                         ndr->offset = _relative_save_offset;
3960                 }
3961         }
3962         return NDR_ERR_SUCCESS;
3963 }
3964
3965 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3966 {
3967         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3968         ndr->depth++;
3969         ndr_print_uint32(ndr, "job_id", r->job_id);
3970         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3971         ndr->depth++;
3972         if (r->printer_name) {
3973                 ndr_print_string(ndr, "printer_name", r->printer_name);
3974         }
3975         ndr->depth--;
3976         ndr_print_ptr(ndr, "server_name", r->server_name);
3977         ndr->depth++;
3978         if (r->server_name) {
3979                 ndr_print_string(ndr, "server_name", r->server_name);
3980         }
3981         ndr->depth--;
3982         ndr_print_ptr(ndr, "user_name", r->user_name);
3983         ndr->depth++;
3984         if (r->user_name) {
3985                 ndr_print_string(ndr, "user_name", r->user_name);
3986         }
3987         ndr->depth--;
3988         ndr_print_ptr(ndr, "document_name", r->document_name);
3989         ndr->depth++;
3990         if (r->document_name) {
3991                 ndr_print_string(ndr, "document_name", r->document_name);
3992         }
3993         ndr->depth--;
3994         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3995         ndr->depth++;
3996         if (r->notify_name) {
3997                 ndr_print_string(ndr, "notify_name", r->notify_name);
3998         }
3999         ndr->depth--;
4000         ndr_print_ptr(ndr, "data_type", r->data_type);
4001         ndr->depth++;
4002         if (r->data_type) {
4003                 ndr_print_string(ndr, "data_type", r->data_type);
4004         }
4005         ndr->depth--;
4006         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4007         ndr->depth++;
4008         if (r->print_processor) {
4009                 ndr_print_string(ndr, "print_processor", r->print_processor);
4010         }
4011         ndr->depth--;
4012         ndr_print_ptr(ndr, "parameters", r->parameters);
4013         ndr->depth++;
4014         if (r->parameters) {
4015                 ndr_print_string(ndr, "parameters", r->parameters);
4016         }
4017         ndr->depth--;
4018         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4019         ndr->depth++;
4020         if (r->driver_name) {
4021                 ndr_print_string(ndr, "driver_name", r->driver_name);
4022         }
4023         ndr->depth--;
4024         ndr_print_ptr(ndr, "devmode", r->devmode);
4025         ndr->depth++;
4026         if (r->devmode) {
4027                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4028         }
4029         ndr->depth--;
4030         ndr_print_ptr(ndr, "text_status", r->text_status);
4031         ndr->depth++;
4032         if (r->text_status) {
4033                 ndr_print_string(ndr, "text_status", r->text_status);
4034         }
4035         ndr->depth--;
4036         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4037         ndr->depth++;
4038         if (r->secdesc) {
4039                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4040         }
4041         ndr->depth--;
4042         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4043         ndr_print_uint32(ndr, "priority", r->priority);
4044         ndr_print_uint32(ndr, "position", r->position);
4045         ndr_print_uint32(ndr, "start_time", r->start_time);
4046         ndr_print_uint32(ndr, "until_time", r->until_time);
4047         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4048         ndr_print_uint32(ndr, "size", r->size);
4049         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4050         ndr_print_uint32(ndr, "time", r->time);
4051         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4052         ndr->depth--;
4053 }
4054
4055 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4056 {
4057         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4058 }
4059
4060 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4061 {
4062         if (ndr_flags & NDR_SCALARS) {
4063                 NDR_CHECK(ndr_push_align(ndr, 4));
4064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4067         }
4068         if (ndr_flags & NDR_BUFFERS) {
4069         }
4070         return NDR_ERR_SUCCESS;
4071 }
4072
4073 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4074 {
4075         if (ndr_flags & NDR_SCALARS) {
4076                 NDR_CHECK(ndr_pull_align(ndr, 4));
4077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4080         }
4081         if (ndr_flags & NDR_BUFFERS) {
4082         }
4083         return NDR_ERR_SUCCESS;
4084 }
4085
4086 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4087 {
4088         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4089         ndr->depth++;
4090         ndr_print_uint32(ndr, "job_id", r->job_id);
4091         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4092         ndr_print_uint32(ndr, "reserved", r->reserved);
4093         ndr->depth--;
4094 }
4095
4096 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4097 {
4098         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4099 }
4100
4101 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4102 {
4103         if (ndr_flags & NDR_SCALARS) {
4104                 NDR_CHECK(ndr_push_align(ndr, 5));
4105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4106                 {
4107                         uint32_t _flags_save_string = ndr->flags;
4108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4109                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4110                         ndr->flags = _flags_save_string;
4111                 }
4112                 {
4113                         uint32_t _flags_save_string = ndr->flags;
4114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4115                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4116                         ndr->flags = _flags_save_string;
4117                 }
4118                 {
4119                         uint32_t _flags_save_string = ndr->flags;
4120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4121                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4122                         ndr->flags = _flags_save_string;
4123                 }
4124                 {
4125                         uint32_t _flags_save_string = ndr->flags;
4126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4127                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4128                         ndr->flags = _flags_save_string;
4129                 }
4130                 {
4131                         uint32_t _flags_save_string = ndr->flags;
4132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4133                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4134                         ndr->flags = _flags_save_string;
4135                 }
4136                 {
4137                         uint32_t _flags_save_string = ndr->flags;
4138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4139                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4140                         ndr->flags = _flags_save_string;
4141                 }
4142                 {
4143                         uint32_t _flags_save_string = ndr->flags;
4144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4145                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4146                         ndr->flags = _flags_save_string;
4147                 }
4148                 {
4149                         uint32_t _flags_save_string = ndr->flags;
4150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4151                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4152                         ndr->flags = _flags_save_string;
4153                 }
4154                 {
4155                         uint32_t _flags_save_string = ndr->flags;
4156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4157                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4158                         ndr->flags = _flags_save_string;
4159                 }
4160                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4161                 {
4162                         uint32_t _flags_save_string = ndr->flags;
4163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4164                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4165                         ndr->flags = _flags_save_string;
4166                 }
4167                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4168                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4175                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4179         }
4180         if (ndr_flags & NDR_BUFFERS) {
4181                 {
4182                         uint32_t _flags_save_string = ndr->flags;
4183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4184                         if (r->printer_name) {
4185                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
4186                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4187                         }
4188                         ndr->flags = _flags_save_string;
4189                 }
4190                 {
4191                         uint32_t _flags_save_string = ndr->flags;
4192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4193                         if (r->server_name) {
4194                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
4195                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4196                         }
4197                         ndr->flags = _flags_save_string;
4198                 }
4199                 {
4200                         uint32_t _flags_save_string = ndr->flags;
4201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4202                         if (r->user_name) {
4203                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
4204                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4205                         }
4206                         ndr->flags = _flags_save_string;
4207                 }
4208                 {
4209                         uint32_t _flags_save_string = ndr->flags;
4210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4211                         if (r->document_name) {
4212                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
4213                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4214                         }
4215                         ndr->flags = _flags_save_string;
4216                 }
4217                 {
4218                         uint32_t _flags_save_string = ndr->flags;
4219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4220                         if (r->notify_name) {
4221                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
4222                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4223                         }
4224                         ndr->flags = _flags_save_string;
4225                 }
4226                 {
4227                         uint32_t _flags_save_string = ndr->flags;
4228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4229                         if (r->data_type) {
4230                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
4231                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4232                         }
4233                         ndr->flags = _flags_save_string;
4234                 }
4235                 {
4236                         uint32_t _flags_save_string = ndr->flags;
4237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4238                         if (r->print_processor) {
4239                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
4240                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4241                         }
4242                         ndr->flags = _flags_save_string;
4243                 }
4244                 {
4245                         uint32_t _flags_save_string = ndr->flags;
4246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4247                         if (r->parameters) {
4248                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
4249                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4250                         }
4251                         ndr->flags = _flags_save_string;
4252                 }
4253                 {
4254                         uint32_t _flags_save_string = ndr->flags;
4255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4256                         if (r->driver_name) {
4257                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4258                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4259                         }
4260                         ndr->flags = _flags_save_string;
4261                 }
4262                 if (r->devmode) {
4263                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
4264                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4265                 }
4266                 {
4267                         uint32_t _flags_save_string = ndr->flags;
4268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4269                         if (r->text_status) {
4270                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
4271                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4272                         }
4273                         ndr->flags = _flags_save_string;
4274                 }
4275                 if (r->secdesc) {
4276                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
4277                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4278                 }
4279         }
4280         return NDR_ERR_SUCCESS;
4281 }
4282
4283 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4284 {
4285         uint32_t _ptr_printer_name;
4286         TALLOC_CTX *_mem_save_printer_name_0;
4287         uint32_t _ptr_server_name;
4288         TALLOC_CTX *_mem_save_server_name_0;
4289         uint32_t _ptr_user_name;
4290         TALLOC_CTX *_mem_save_user_name_0;
4291         uint32_t _ptr_document_name;
4292         TALLOC_CTX *_mem_save_document_name_0;
4293         uint32_t _ptr_notify_name;
4294         TALLOC_CTX *_mem_save_notify_name_0;
4295         uint32_t _ptr_data_type;
4296         TALLOC_CTX *_mem_save_data_type_0;
4297         uint32_t _ptr_print_processor;
4298         TALLOC_CTX *_mem_save_print_processor_0;
4299         uint32_t _ptr_parameters;
4300         TALLOC_CTX *_mem_save_parameters_0;
4301         uint32_t _ptr_driver_name;
4302         TALLOC_CTX *_mem_save_driver_name_0;
4303         uint32_t _ptr_devmode;
4304         TALLOC_CTX *_mem_save_devmode_0;
4305         uint32_t _ptr_text_status;
4306         TALLOC_CTX *_mem_save_text_status_0;
4307         uint32_t _ptr_secdesc;
4308         TALLOC_CTX *_mem_save_secdesc_0;
4309         if (ndr_flags & NDR_SCALARS) {
4310                 NDR_CHECK(ndr_pull_align(ndr, 5));
4311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4312                 {
4313                         uint32_t _flags_save_string = ndr->flags;
4314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4316                         if (_ptr_printer_name) {
4317                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4319                         } else {
4320                                 r->printer_name = NULL;
4321                         }
4322                         ndr->flags = _flags_save_string;
4323                 }
4324                 {
4325                         uint32_t _flags_save_string = ndr->flags;
4326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4327                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4328                         if (_ptr_server_name) {
4329                                 NDR_PULL_ALLOC(ndr, r->server_name);
4330                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4331                         } else {
4332                                 r->server_name = NULL;
4333                         }
4334                         ndr->flags = _flags_save_string;
4335                 }
4336                 {
4337                         uint32_t _flags_save_string = ndr->flags;
4338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4339                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4340                         if (_ptr_user_name) {
4341                                 NDR_PULL_ALLOC(ndr, r->user_name);
4342                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4343                         } else {
4344                                 r->user_name = NULL;
4345                         }
4346                         ndr->flags = _flags_save_string;
4347                 }
4348                 {
4349                         uint32_t _flags_save_string = ndr->flags;
4350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4352                         if (_ptr_document_name) {
4353                                 NDR_PULL_ALLOC(ndr, r->document_name);
4354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4355                         } else {
4356                                 r->document_name = NULL;
4357                         }
4358                         ndr->flags = _flags_save_string;
4359                 }
4360                 {
4361                         uint32_t _flags_save_string = ndr->flags;
4362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4363                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4364                         if (_ptr_notify_name) {
4365                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4366                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4367                         } else {
4368                                 r->notify_name = NULL;
4369                         }
4370                         ndr->flags = _flags_save_string;
4371                 }
4372                 {
4373                         uint32_t _flags_save_string = ndr->flags;
4374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4375                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4376                         if (_ptr_data_type) {
4377                                 NDR_PULL_ALLOC(ndr, r->data_type);
4378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4379                         } else {
4380                                 r->data_type = NULL;
4381                         }
4382                         ndr->flags = _flags_save_string;
4383                 }
4384                 {
4385                         uint32_t _flags_save_string = ndr->flags;
4386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4387                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4388                         if (_ptr_print_processor) {
4389                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4390                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4391                         } else {
4392                                 r->print_processor = NULL;
4393                         }
4394                         ndr->flags = _flags_save_string;
4395                 }
4396                 {
4397                         uint32_t _flags_save_string = ndr->flags;
4398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4399                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4400                         if (_ptr_parameters) {
4401                                 NDR_PULL_ALLOC(ndr, r->parameters);
4402                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4403                         } else {
4404                                 r->parameters = NULL;
4405                         }
4406                         ndr->flags = _flags_save_string;
4407                 }
4408                 {
4409                         uint32_t _flags_save_string = ndr->flags;
4410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4411                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4412                         if (_ptr_driver_name) {
4413                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4414                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4415                         } else {
4416                                 r->driver_name = NULL;
4417                         }
4418                         ndr->flags = _flags_save_string;
4419                 }
4420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4421                 if (_ptr_devmode) {
4422                         NDR_PULL_ALLOC(ndr, r->devmode);
4423                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4424                 } else {
4425                         r->devmode = NULL;
4426                 }
4427                 {
4428                         uint32_t _flags_save_string = ndr->flags;
4429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4430                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4431                         if (_ptr_text_status) {
4432                                 NDR_PULL_ALLOC(ndr, r->text_status);
4433                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4434                         } else {
4435                                 r->text_status = NULL;
4436                         }
4437                         ndr->flags = _flags_save_string;
4438                 }
4439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4440                 if (_ptr_secdesc) {
4441                         NDR_PULL_ALLOC(ndr, r->secdesc);
4442                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4443                 } else {
4444                         r->secdesc = NULL;
4445                 }
4446                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4448                 if (r->priority > 99) {
4449                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4450                 }
4451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4456                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4460         }
4461         if (ndr_flags & NDR_BUFFERS) {
4462                 {
4463                         uint32_t _flags_save_string = ndr->flags;
4464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4465                         if (r->printer_name) {
4466                                 uint32_t _relative_save_offset;
4467                                 _relative_save_offset = ndr->offset;
4468                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4469                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4470                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4471                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4472                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4473                                 ndr->offset = _relative_save_offset;
4474                         }
4475                         ndr->flags = _flags_save_string;
4476                 }
4477                 {
4478                         uint32_t _flags_save_string = ndr->flags;
4479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4480                         if (r->server_name) {
4481                                 uint32_t _relative_save_offset;
4482                                 _relative_save_offset = ndr->offset;
4483                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4484                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4485                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4486                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4487                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4488                                 ndr->offset = _relative_save_offset;
4489                         }
4490                         ndr->flags = _flags_save_string;
4491                 }
4492                 {
4493                         uint32_t _flags_save_string = ndr->flags;
4494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4495                         if (r->user_name) {
4496                                 uint32_t _relative_save_offset;
4497                                 _relative_save_offset = ndr->offset;
4498                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4499                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4500                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4501                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4502                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4503                                 ndr->offset = _relative_save_offset;
4504                         }
4505                         ndr->flags = _flags_save_string;
4506                 }
4507                 {
4508                         uint32_t _flags_save_string = ndr->flags;
4509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4510                         if (r->document_name) {
4511                                 uint32_t _relative_save_offset;
4512                                 _relative_save_offset = ndr->offset;
4513                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4514                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4515                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4516                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4517                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4518                                 ndr->offset = _relative_save_offset;
4519                         }
4520                         ndr->flags = _flags_save_string;
4521                 }
4522                 {
4523                         uint32_t _flags_save_string = ndr->flags;
4524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4525                         if (r->notify_name) {
4526                                 uint32_t _relative_save_offset;
4527                                 _relative_save_offset = ndr->offset;
4528                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4529                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4530                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4531                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4532                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4533                                 ndr->offset = _relative_save_offset;
4534                         }
4535                         ndr->flags = _flags_save_string;
4536                 }
4537                 {
4538                         uint32_t _flags_save_string = ndr->flags;
4539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4540                         if (r->data_type) {
4541                                 uint32_t _relative_save_offset;
4542                                 _relative_save_offset = ndr->offset;
4543                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4544                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4545                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4546                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4547                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4548                                 ndr->offset = _relative_save_offset;
4549                         }
4550                         ndr->flags = _flags_save_string;
4551                 }
4552                 {
4553                         uint32_t _flags_save_string = ndr->flags;
4554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4555                         if (r->print_processor) {
4556                                 uint32_t _relative_save_offset;
4557                                 _relative_save_offset = ndr->offset;
4558                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4559                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4560                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4561                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4562                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4563                                 ndr->offset = _relative_save_offset;
4564                         }
4565                         ndr->flags = _flags_save_string;
4566                 }
4567                 {
4568                         uint32_t _flags_save_string = ndr->flags;
4569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4570                         if (r->parameters) {
4571                                 uint32_t _relative_save_offset;
4572                                 _relative_save_offset = ndr->offset;
4573                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4574                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4575                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4576                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4577                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4578                                 ndr->offset = _relative_save_offset;
4579                         }
4580                         ndr->flags = _flags_save_string;
4581                 }
4582                 {
4583                         uint32_t _flags_save_string = ndr->flags;
4584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4585                         if (r->driver_name) {
4586                                 uint32_t _relative_save_offset;
4587                                 _relative_save_offset = ndr->offset;
4588                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4589                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4590                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4591                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4592                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4593                                 ndr->offset = _relative_save_offset;
4594                         }
4595                         ndr->flags = _flags_save_string;
4596                 }
4597                 if (r->devmode) {
4598                         uint32_t _relative_save_offset;
4599                         _relative_save_offset = ndr->offset;
4600                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4601                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4602                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4603                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4605                         ndr->offset = _relative_save_offset;
4606                 }
4607                 {
4608                         uint32_t _flags_save_string = ndr->flags;
4609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4610                         if (r->text_status) {
4611                                 uint32_t _relative_save_offset;
4612                                 _relative_save_offset = ndr->offset;
4613                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4614                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4615                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4616                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4617                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4618                                 ndr->offset = _relative_save_offset;
4619                         }
4620                         ndr->flags = _flags_save_string;
4621                 }
4622                 if (r->secdesc) {
4623                         uint32_t _relative_save_offset;
4624                         _relative_save_offset = ndr->offset;
4625                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4626                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4627                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4628                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4630                         ndr->offset = _relative_save_offset;
4631                 }
4632         }
4633         return NDR_ERR_SUCCESS;
4634 }
4635
4636 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4637 {
4638         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4639         ndr->depth++;
4640         ndr_print_uint32(ndr, "job_id", r->job_id);
4641         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4642         ndr->depth++;
4643         if (r->printer_name) {
4644                 ndr_print_string(ndr, "printer_name", r->printer_name);
4645         }
4646         ndr->depth--;
4647         ndr_print_ptr(ndr, "server_name", r->server_name);
4648         ndr->depth++;
4649         if (r->server_name) {
4650                 ndr_print_string(ndr, "server_name", r->server_name);
4651         }
4652         ndr->depth--;
4653         ndr_print_ptr(ndr, "user_name", r->user_name);
4654         ndr->depth++;
4655         if (r->user_name) {
4656                 ndr_print_string(ndr, "user_name", r->user_name);
4657         }
4658         ndr->depth--;
4659         ndr_print_ptr(ndr, "document_name", r->document_name);
4660         ndr->depth++;
4661         if (r->document_name) {
4662                 ndr_print_string(ndr, "document_name", r->document_name);
4663         }
4664         ndr->depth--;
4665         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4666         ndr->depth++;
4667         if (r->notify_name) {
4668                 ndr_print_string(ndr, "notify_name", r->notify_name);
4669         }
4670         ndr->depth--;
4671         ndr_print_ptr(ndr, "data_type", r->data_type);
4672         ndr->depth++;
4673         if (r->data_type) {
4674                 ndr_print_string(ndr, "data_type", r->data_type);
4675         }
4676         ndr->depth--;
4677         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4678         ndr->depth++;
4679         if (r->print_processor) {
4680                 ndr_print_string(ndr, "print_processor", r->print_processor);
4681         }
4682         ndr->depth--;
4683         ndr_print_ptr(ndr, "parameters", r->parameters);
4684         ndr->depth++;
4685         if (r->parameters) {
4686                 ndr_print_string(ndr, "parameters", r->parameters);
4687         }
4688         ndr->depth--;
4689         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4690         ndr->depth++;
4691         if (r->driver_name) {
4692                 ndr_print_string(ndr, "driver_name", r->driver_name);
4693         }
4694         ndr->depth--;
4695         ndr_print_ptr(ndr, "devmode", r->devmode);
4696         ndr->depth++;
4697         if (r->devmode) {
4698                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4699         }
4700         ndr->depth--;
4701         ndr_print_ptr(ndr, "text_status", r->text_status);
4702         ndr->depth++;
4703         if (r->text_status) {
4704                 ndr_print_string(ndr, "text_status", r->text_status);
4705         }
4706         ndr->depth--;
4707         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4708         ndr->depth++;
4709         if (r->secdesc) {
4710                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4711         }
4712         ndr->depth--;
4713         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4714         ndr_print_uint32(ndr, "priority", r->priority);
4715         ndr_print_uint32(ndr, "position", r->position);
4716         ndr_print_uint32(ndr, "start_time", r->start_time);
4717         ndr_print_uint32(ndr, "until_time", r->until_time);
4718         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4719         ndr_print_uint32(ndr, "size", r->size);
4720         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4721         ndr_print_uint32(ndr, "time", r->time);
4722         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4723         ndr_print_uint32(ndr, "size_high", r->size_high);
4724         ndr->depth--;
4725 }
4726
4727 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4728 {
4729         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4730 }
4731
4732 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4733 {
4734         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4735         if (ndr_flags & NDR_SCALARS) {
4736                 int level = ndr_push_get_switch_value(ndr, r);
4737                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4738                 switch (level) {
4739                         case 1: {
4740                                 NDR_CHECK(ndr_push_align(ndr, 5));
4741                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4742                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4743                         break; }
4744
4745                         case 2: {
4746                                 NDR_CHECK(ndr_push_align(ndr, 5));
4747                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4748                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4749                         break; }
4750
4751                         case 3: {
4752                                 NDR_CHECK(ndr_push_align(ndr, 4));
4753                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4754                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4755                         break; }
4756
4757                         case 4: {
4758                                 NDR_CHECK(ndr_push_align(ndr, 5));
4759                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4760                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4761                         break; }
4762
4763                         default: {
4764                         break; }
4765
4766                 }
4767         }
4768         if (ndr_flags & NDR_BUFFERS) {
4769                 int level = ndr_push_get_switch_value(ndr, r);
4770                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4771                 switch (level) {
4772                         case 1:
4773                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4774                         break;
4775
4776                         case 2:
4777                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4778                         break;
4779
4780                         case 3:
4781                         break;
4782
4783                         case 4:
4784                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4785                         break;
4786
4787                         default:
4788                         break;
4789
4790                 }
4791         }
4792         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4793         return NDR_ERR_SUCCESS;
4794 }
4795
4796 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4797 {
4798         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4799         int level;
4800         level = ndr_pull_get_switch_value(ndr, r);
4801         if (ndr_flags & NDR_SCALARS) {
4802                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4803                 switch (level) {
4804                         case 1: {
4805                                 NDR_CHECK(ndr_pull_align(ndr, 5));
4806                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4807                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4808                         break; }
4809
4810                         case 2: {
4811                                 NDR_CHECK(ndr_pull_align(ndr, 5));
4812                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4813                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4814                         break; }
4815
4816                         case 3: {
4817                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4818                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4819                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4820                         break; }
4821
4822                         case 4: {
4823                                 NDR_CHECK(ndr_pull_align(ndr, 5));
4824                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4825                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4826                         break; }
4827
4828                         default: {
4829                         break; }
4830
4831                 }
4832         }
4833         if (ndr_flags & NDR_BUFFERS) {
4834                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4835                 switch (level) {
4836                         case 1:
4837                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4838                         break;
4839
4840                         case 2:
4841                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4842                         break;
4843
4844                         case 3:
4845                         break;
4846
4847                         case 4:
4848                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4849                         break;
4850
4851                         default:
4852                         break;
4853
4854                 }
4855         }
4856         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4857         return NDR_ERR_SUCCESS;
4858 }
4859
4860 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4861 {
4862         int level;
4863         level = ndr_print_get_switch_value(ndr, r);
4864         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4865         switch (level) {
4866                 case 1:
4867                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4868                 break;
4869
4870                 case 2:
4871                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4872                 break;
4873
4874                 case 3:
4875                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4876                 break;
4877
4878                 case 4:
4879                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4880                 break;
4881
4882                 default:
4883                 break;
4884
4885         }
4886 }
4887
4888 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4889 {
4890         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4891 }
4892
4893 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4894 {
4895         if (ndr_flags & NDR_SCALARS) {
4896                 NDR_CHECK(ndr_push_align(ndr, 5));
4897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4901                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4904                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4909                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4910         }
4911         if (ndr_flags & NDR_BUFFERS) {
4912                 if (r->printer_name) {
4913                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4915                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4916                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4917                 }
4918                 if (r->server_name) {
4919                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4920                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4921                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4922                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4923                 }
4924                 if (r->user_name) {
4925                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4928                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4929                 }
4930                 if (r->document_name) {
4931                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4934                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4935                 }
4936                 if (r->data_type) {
4937                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4940                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4941                 }
4942                 if (r->text_status) {
4943                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4944                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4946                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4947                 }
4948         }
4949         return NDR_ERR_SUCCESS;
4950 }
4951
4952 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4953 {
4954         uint32_t _ptr_printer_name;
4955         TALLOC_CTX *_mem_save_printer_name_0;
4956         uint32_t _ptr_server_name;
4957         TALLOC_CTX *_mem_save_server_name_0;
4958         uint32_t _ptr_user_name;
4959         TALLOC_CTX *_mem_save_user_name_0;
4960         uint32_t _ptr_document_name;
4961         TALLOC_CTX *_mem_save_document_name_0;
4962         uint32_t _ptr_data_type;
4963         TALLOC_CTX *_mem_save_data_type_0;
4964         uint32_t _ptr_text_status;
4965         TALLOC_CTX *_mem_save_text_status_0;
4966         if (ndr_flags & NDR_SCALARS) {
4967                 NDR_CHECK(ndr_pull_align(ndr, 5));
4968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4970                 if (_ptr_printer_name) {
4971                         NDR_PULL_ALLOC(ndr, r->printer_name);
4972                 } else {
4973                         r->printer_name = NULL;
4974                 }
4975                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4976                 if (_ptr_server_name) {
4977                         NDR_PULL_ALLOC(ndr, r->server_name);
4978                 } else {
4979                         r->server_name = NULL;
4980                 }
4981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4982                 if (_ptr_user_name) {
4983                         NDR_PULL_ALLOC(ndr, r->user_name);
4984                 } else {
4985                         r->user_name = NULL;
4986                 }
4987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4988                 if (_ptr_document_name) {
4989                         NDR_PULL_ALLOC(ndr, r->document_name);
4990                 } else {
4991                         r->document_name = NULL;
4992                 }
4993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4994                 if (_ptr_data_type) {
4995                         NDR_PULL_ALLOC(ndr, r->data_type);
4996                 } else {
4997                         r->data_type = NULL;
4998                 }
4999                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5000                 if (_ptr_text_status) {
5001                         NDR_PULL_ALLOC(ndr, r->text_status);
5002                 } else {
5003                         r->text_status = NULL;
5004                 }
5005                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5007                 if (r->priority > 99) {
5008                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5009                 }
5010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5013                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5014         }
5015         if (ndr_flags & NDR_BUFFERS) {
5016                 if (r->printer_name) {
5017                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5018                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5021                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5022                                 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));
5023                         }
5024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5027                 }
5028                 if (r->server_name) {
5029                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5030                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5033                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5034                                 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));
5035                         }
5036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5039                 }
5040                 if (r->user_name) {
5041                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5042                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5044                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5045                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5046                                 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));
5047                         }
5048                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5049                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5051                 }
5052                 if (r->document_name) {
5053                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5054                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5057                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5058                                 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));
5059                         }
5060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5063                 }
5064                 if (r->data_type) {
5065                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5066                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5069                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5070                                 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));
5071                         }
5072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5073                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5075                 }
5076                 if (r->text_status) {
5077                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5078                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5081                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5082                                 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));
5083                         }
5084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5087                 }
5088         }
5089         return NDR_ERR_SUCCESS;
5090 }
5091
5092 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5093 {
5094         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5095         ndr->depth++;
5096         ndr_print_uint32(ndr, "job_id", r->job_id);
5097         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5098         ndr->depth++;
5099         if (r->printer_name) {
5100                 ndr_print_string(ndr, "printer_name", r->printer_name);
5101         }
5102         ndr->depth--;
5103         ndr_print_ptr(ndr, "server_name", r->server_name);
5104         ndr->depth++;
5105         if (r->server_name) {
5106                 ndr_print_string(ndr, "server_name", r->server_name);
5107         }
5108         ndr->depth--;
5109         ndr_print_ptr(ndr, "user_name", r->user_name);
5110         ndr->depth++;
5111         if (r->user_name) {
5112                 ndr_print_string(ndr, "user_name", r->user_name);
5113         }
5114         ndr->depth--;
5115         ndr_print_ptr(ndr, "document_name", r->document_name);
5116         ndr->depth++;
5117         if (r->document_name) {
5118                 ndr_print_string(ndr, "document_name", r->document_name);
5119         }
5120         ndr->depth--;
5121         ndr_print_ptr(ndr, "data_type", r->data_type);
5122         ndr->depth++;
5123         if (r->data_type) {
5124                 ndr_print_string(ndr, "data_type", r->data_type);
5125         }
5126         ndr->depth--;
5127         ndr_print_ptr(ndr, "text_status", r->text_status);
5128         ndr->depth++;
5129         if (r->text_status) {
5130                 ndr_print_string(ndr, "text_status", r->text_status);
5131         }
5132         ndr->depth--;
5133         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5134         ndr_print_uint32(ndr, "priority", r->priority);
5135         ndr_print_uint32(ndr, "position", r->position);
5136         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5137         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5138         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5139         ndr->depth--;
5140 }
5141
5142 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5143 {
5144         if (ndr_flags & NDR_SCALARS) {
5145                 NDR_CHECK(ndr_push_align(ndr, 5));
5146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5147                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5152                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5159                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5166                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5169         }
5170         if (ndr_flags & NDR_BUFFERS) {
5171                 if (r->printer_name) {
5172                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5173                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5175                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5176                 }
5177                 if (r->server_name) {
5178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5179                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5181                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5182                 }
5183                 if (r->user_name) {
5184                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5185                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5186                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5187                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5188                 }
5189                 if (r->document_name) {
5190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5193                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5194                 }
5195                 if (r->notify_name) {
5196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5197                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5199                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5200                 }
5201                 if (r->data_type) {
5202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5203                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5204                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5205                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5206                 }
5207                 if (r->print_processor) {
5208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5212                 }
5213                 if (r->parameters) {
5214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5217                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5218                 }
5219                 if (r->driver_name) {
5220                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5221                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5222                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5223                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5224                 }
5225                 if (r->text_status) {
5226                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5227                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5228                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5229                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5230                 }
5231         }
5232         return NDR_ERR_SUCCESS;
5233 }
5234
5235 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5236 {
5237         uint32_t _ptr_printer_name;
5238         TALLOC_CTX *_mem_save_printer_name_0;
5239         uint32_t _ptr_server_name;
5240         TALLOC_CTX *_mem_save_server_name_0;
5241         uint32_t _ptr_user_name;
5242         TALLOC_CTX *_mem_save_user_name_0;
5243         uint32_t _ptr_document_name;
5244         TALLOC_CTX *_mem_save_document_name_0;
5245         uint32_t _ptr_notify_name;
5246         TALLOC_CTX *_mem_save_notify_name_0;
5247         uint32_t _ptr_data_type;
5248         TALLOC_CTX *_mem_save_data_type_0;
5249         uint32_t _ptr_print_processor;
5250         TALLOC_CTX *_mem_save_print_processor_0;
5251         uint32_t _ptr_parameters;
5252         TALLOC_CTX *_mem_save_parameters_0;
5253         uint32_t _ptr_driver_name;
5254         TALLOC_CTX *_mem_save_driver_name_0;
5255         uint32_t _ptr_text_status;
5256         TALLOC_CTX *_mem_save_text_status_0;
5257         if (ndr_flags & NDR_SCALARS) {
5258                 NDR_CHECK(ndr_pull_align(ndr, 5));
5259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5261                 if (_ptr_printer_name) {
5262                         NDR_PULL_ALLOC(ndr, r->printer_name);
5263                 } else {
5264                         r->printer_name = NULL;
5265                 }
5266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5267                 if (_ptr_server_name) {
5268                         NDR_PULL_ALLOC(ndr, r->server_name);
5269                 } else {
5270                         r->server_name = NULL;
5271                 }
5272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5273                 if (_ptr_user_name) {
5274                         NDR_PULL_ALLOC(ndr, r->user_name);
5275                 } else {
5276                         r->user_name = NULL;
5277                 }
5278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5279                 if (_ptr_document_name) {
5280                         NDR_PULL_ALLOC(ndr, r->document_name);
5281                 } else {
5282                         r->document_name = NULL;
5283                 }
5284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5285                 if (_ptr_notify_name) {
5286                         NDR_PULL_ALLOC(ndr, r->notify_name);
5287                 } else {
5288                         r->notify_name = NULL;
5289                 }
5290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5291                 if (_ptr_data_type) {
5292                         NDR_PULL_ALLOC(ndr, r->data_type);
5293                 } else {
5294                         r->data_type = NULL;
5295                 }
5296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5297                 if (_ptr_print_processor) {
5298                         NDR_PULL_ALLOC(ndr, r->print_processor);
5299                 } else {
5300                         r->print_processor = NULL;
5301                 }
5302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5303                 if (_ptr_parameters) {
5304                         NDR_PULL_ALLOC(ndr, r->parameters);
5305                 } else {
5306                         r->parameters = NULL;
5307                 }
5308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5309                 if (_ptr_driver_name) {
5310                         NDR_PULL_ALLOC(ndr, r->driver_name);
5311                 } else {
5312                         r->driver_name = NULL;
5313                 }
5314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5316                 if (_ptr_text_status) {
5317                         NDR_PULL_ALLOC(ndr, r->text_status);
5318                 } else {
5319                         r->text_status = NULL;
5320                 }
5321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5322                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5324                 if (r->priority > 99) {
5325                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5326                 }
5327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5332                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5335         }
5336         if (ndr_flags & NDR_BUFFERS) {
5337                 if (r->printer_name) {
5338                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5339                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5341                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5342                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5343                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5344                         }
5345                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5346                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5348                 }
5349                 if (r->server_name) {
5350                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5351                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5353                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5354                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5355                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5356                         }
5357                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5358                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5360                 }
5361                 if (r->user_name) {
5362                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5363                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5366                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5367                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5368                         }
5369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5372                 }
5373                 if (r->document_name) {
5374                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5375                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5377                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5378                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5379                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5380                         }
5381                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5382                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5384                 }
5385                 if (r->notify_name) {
5386                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5387                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5388                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5389                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5390                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5391                                 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));
5392                         }
5393                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5394                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5396                 }
5397                 if (r->data_type) {
5398                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5399                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5400                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5401                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5402                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5403                                 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));
5404                         }
5405                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5406                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5408                 }
5409                 if (r->print_processor) {
5410                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5411                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5412                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5413                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5414                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5415                                 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));
5416                         }
5417                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5418                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5419                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5420                 }
5421                 if (r->parameters) {
5422                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5423                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5425                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5426                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5427                                 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));
5428                         }
5429                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5430                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5432                 }
5433                 if (r->driver_name) {
5434                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5435                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5436                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5437                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5438                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5439                                 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));
5440                         }
5441                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5442                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5444                 }
5445                 if (r->text_status) {
5446                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5447                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5448                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5449                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5450                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5451                                 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));
5452                         }
5453                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5454                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5455                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5456                 }
5457         }
5458         return NDR_ERR_SUCCESS;
5459 }
5460
5461 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5462 {
5463         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5464         ndr->depth++;
5465         ndr_print_uint32(ndr, "job_id", r->job_id);
5466         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5467         ndr->depth++;
5468         if (r->printer_name) {
5469                 ndr_print_string(ndr, "printer_name", r->printer_name);
5470         }
5471         ndr->depth--;
5472         ndr_print_ptr(ndr, "server_name", r->server_name);
5473         ndr->depth++;
5474         if (r->server_name) {
5475                 ndr_print_string(ndr, "server_name", r->server_name);
5476         }
5477         ndr->depth--;
5478         ndr_print_ptr(ndr, "user_name", r->user_name);
5479         ndr->depth++;
5480         if (r->user_name) {
5481                 ndr_print_string(ndr, "user_name", r->user_name);
5482         }
5483         ndr->depth--;
5484         ndr_print_ptr(ndr, "document_name", r->document_name);
5485         ndr->depth++;
5486         if (r->document_name) {
5487                 ndr_print_string(ndr, "document_name", r->document_name);
5488         }
5489         ndr->depth--;
5490         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5491         ndr->depth++;
5492         if (r->notify_name) {
5493                 ndr_print_string(ndr, "notify_name", r->notify_name);
5494         }
5495         ndr->depth--;
5496         ndr_print_ptr(ndr, "data_type", r->data_type);
5497         ndr->depth++;
5498         if (r->data_type) {
5499                 ndr_print_string(ndr, "data_type", r->data_type);
5500         }
5501         ndr->depth--;
5502         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5503         ndr->depth++;
5504         if (r->print_processor) {
5505                 ndr_print_string(ndr, "print_processor", r->print_processor);
5506         }
5507         ndr->depth--;
5508         ndr_print_ptr(ndr, "parameters", r->parameters);
5509         ndr->depth++;
5510         if (r->parameters) {
5511                 ndr_print_string(ndr, "parameters", r->parameters);
5512         }
5513         ndr->depth--;
5514         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5515         ndr->depth++;
5516         if (r->driver_name) {
5517                 ndr_print_string(ndr, "driver_name", r->driver_name);
5518         }
5519         ndr->depth--;
5520         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5521         ndr_print_ptr(ndr, "text_status", r->text_status);
5522         ndr->depth++;
5523         if (r->text_status) {
5524                 ndr_print_string(ndr, "text_status", r->text_status);
5525         }
5526         ndr->depth--;
5527         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5528         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5529         ndr_print_uint32(ndr, "priority", r->priority);
5530         ndr_print_uint32(ndr, "position", r->position);
5531         ndr_print_uint32(ndr, "start_time", r->start_time);
5532         ndr_print_uint32(ndr, "until_time", r->until_time);
5533         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5534         ndr_print_uint32(ndr, "size", r->size);
5535         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5536         ndr_print_uint32(ndr, "time", r->time);
5537         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5538         ndr->depth--;
5539 }
5540
5541 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5542 {
5543         if (ndr_flags & NDR_SCALARS) {
5544                 NDR_CHECK(ndr_push_align(ndr, 5));
5545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5547                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5549                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5550                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5551                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5554                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5558                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5565                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5569         }
5570         if (ndr_flags & NDR_BUFFERS) {
5571                 if (r->printer_name) {
5572                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5573                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5574                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5575                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5576                 }
5577                 if (r->server_name) {
5578                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5579                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5581                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5582                 }
5583                 if (r->user_name) {
5584                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5585                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5586                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5587                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5588                 }
5589                 if (r->document_name) {
5590                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5591                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5592                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5593                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5594                 }
5595                 if (r->notify_name) {
5596                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5597                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5598                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5599                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5600                 }
5601                 if (r->data_type) {
5602                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5605                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5606                 }
5607                 if (r->print_processor) {
5608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5611                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5612                 }
5613                 if (r->parameters) {
5614                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5615                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5616                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5617                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5618                 }
5619                 if (r->driver_name) {
5620                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5623                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5624                 }
5625                 if (r->text_status) {
5626                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5629                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5630                 }
5631         }
5632         return NDR_ERR_SUCCESS;
5633 }
5634
5635 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5636 {
5637         uint32_t _ptr_printer_name;
5638         TALLOC_CTX *_mem_save_printer_name_0;
5639         uint32_t _ptr_server_name;
5640         TALLOC_CTX *_mem_save_server_name_0;
5641         uint32_t _ptr_user_name;
5642         TALLOC_CTX *_mem_save_user_name_0;
5643         uint32_t _ptr_document_name;
5644         TALLOC_CTX *_mem_save_document_name_0;
5645         uint32_t _ptr_notify_name;
5646         TALLOC_CTX *_mem_save_notify_name_0;
5647         uint32_t _ptr_data_type;
5648         TALLOC_CTX *_mem_save_data_type_0;
5649         uint32_t _ptr_print_processor;
5650         TALLOC_CTX *_mem_save_print_processor_0;
5651         uint32_t _ptr_parameters;
5652         TALLOC_CTX *_mem_save_parameters_0;
5653         uint32_t _ptr_driver_name;
5654         TALLOC_CTX *_mem_save_driver_name_0;
5655         uint32_t _ptr_text_status;
5656         TALLOC_CTX *_mem_save_text_status_0;
5657         if (ndr_flags & NDR_SCALARS) {
5658                 NDR_CHECK(ndr_pull_align(ndr, 5));
5659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5661                 if (_ptr_printer_name) {
5662                         NDR_PULL_ALLOC(ndr, r->printer_name);
5663                 } else {
5664                         r->printer_name = NULL;
5665                 }
5666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5667                 if (_ptr_server_name) {
5668                         NDR_PULL_ALLOC(ndr, r->server_name);
5669                 } else {
5670                         r->server_name = NULL;
5671                 }
5672                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5673                 if (_ptr_user_name) {
5674                         NDR_PULL_ALLOC(ndr, r->user_name);
5675                 } else {
5676                         r->user_name = NULL;
5677                 }
5678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5679                 if (_ptr_document_name) {
5680                         NDR_PULL_ALLOC(ndr, r->document_name);
5681                 } else {
5682                         r->document_name = NULL;
5683                 }
5684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5685                 if (_ptr_notify_name) {
5686                         NDR_PULL_ALLOC(ndr, r->notify_name);
5687                 } else {
5688                         r->notify_name = NULL;
5689                 }
5690                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5691                 if (_ptr_data_type) {
5692                         NDR_PULL_ALLOC(ndr, r->data_type);
5693                 } else {
5694                         r->data_type = NULL;
5695                 }
5696                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5697                 if (_ptr_print_processor) {
5698                         NDR_PULL_ALLOC(ndr, r->print_processor);
5699                 } else {
5700                         r->print_processor = NULL;
5701                 }
5702                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5703                 if (_ptr_parameters) {
5704                         NDR_PULL_ALLOC(ndr, r->parameters);
5705                 } else {
5706                         r->parameters = NULL;
5707                 }
5708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5709                 if (_ptr_driver_name) {
5710                         NDR_PULL_ALLOC(ndr, r->driver_name);
5711                 } else {
5712                         r->driver_name = NULL;
5713                 }
5714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5716                 if (_ptr_text_status) {
5717                         NDR_PULL_ALLOC(ndr, r->text_status);
5718                 } else {
5719                         r->text_status = NULL;
5720                 }
5721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5722                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5724                 if (r->priority > 99) {
5725                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5726                 }
5727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5732                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5736         }
5737         if (ndr_flags & NDR_BUFFERS) {
5738                 if (r->printer_name) {
5739                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5740                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5743                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5744                                 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));
5745                         }
5746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5749                 }
5750                 if (r->server_name) {
5751                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5752                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5755                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5756                                 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));
5757                         }
5758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5761                 }
5762                 if (r->user_name) {
5763                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5764                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5767                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5768                                 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));
5769                         }
5770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5773                 }
5774                 if (r->document_name) {
5775                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5776                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5779                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5780                                 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));
5781                         }
5782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5783                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5785                 }
5786                 if (r->notify_name) {
5787                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5788                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5790                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5791                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5792                                 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));
5793                         }
5794                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5795                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5796                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5797                 }
5798                 if (r->data_type) {
5799                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5800                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5802                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5803                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5804                                 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));
5805                         }
5806                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5807                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5809                 }
5810                 if (r->print_processor) {
5811                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5812                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5815                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5816                                 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));
5817                         }
5818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5821                 }
5822                 if (r->parameters) {
5823                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5824                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5825                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5826                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5827                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5828                                 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));
5829                         }
5830                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5831                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5832                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5833                 }
5834                 if (r->driver_name) {
5835                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5836                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5838                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5839                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5840                                 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));
5841                         }
5842                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5843                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5845                 }
5846                 if (r->text_status) {
5847                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5848                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5851                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5852                                 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));
5853                         }
5854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5857                 }
5858         }
5859         return NDR_ERR_SUCCESS;
5860 }
5861
5862 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5863 {
5864         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5865         ndr->depth++;
5866         ndr_print_uint32(ndr, "job_id", r->job_id);
5867         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5868         ndr->depth++;
5869         if (r->printer_name) {
5870                 ndr_print_string(ndr, "printer_name", r->printer_name);
5871         }
5872         ndr->depth--;
5873         ndr_print_ptr(ndr, "server_name", r->server_name);
5874         ndr->depth++;
5875         if (r->server_name) {
5876                 ndr_print_string(ndr, "server_name", r->server_name);
5877         }
5878         ndr->depth--;
5879         ndr_print_ptr(ndr, "user_name", r->user_name);
5880         ndr->depth++;
5881         if (r->user_name) {
5882                 ndr_print_string(ndr, "user_name", r->user_name);
5883         }
5884         ndr->depth--;
5885         ndr_print_ptr(ndr, "document_name", r->document_name);
5886         ndr->depth++;
5887         if (r->document_name) {
5888                 ndr_print_string(ndr, "document_name", r->document_name);
5889         }
5890         ndr->depth--;
5891         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5892         ndr->depth++;
5893         if (r->notify_name) {
5894                 ndr_print_string(ndr, "notify_name", r->notify_name);
5895         }
5896         ndr->depth--;
5897         ndr_print_ptr(ndr, "data_type", r->data_type);
5898         ndr->depth++;
5899         if (r->data_type) {
5900                 ndr_print_string(ndr, "data_type", r->data_type);
5901         }
5902         ndr->depth--;
5903         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5904         ndr->depth++;
5905         if (r->print_processor) {
5906                 ndr_print_string(ndr, "print_processor", r->print_processor);
5907         }
5908         ndr->depth--;
5909         ndr_print_ptr(ndr, "parameters", r->parameters);
5910         ndr->depth++;
5911         if (r->parameters) {
5912                 ndr_print_string(ndr, "parameters", r->parameters);
5913         }
5914         ndr->depth--;
5915         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5916         ndr->depth++;
5917         if (r->driver_name) {
5918                 ndr_print_string(ndr, "driver_name", r->driver_name);
5919         }
5920         ndr->depth--;
5921         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5922         ndr_print_ptr(ndr, "text_status", r->text_status);
5923         ndr->depth++;
5924         if (r->text_status) {
5925                 ndr_print_string(ndr, "text_status", r->text_status);
5926         }
5927         ndr->depth--;
5928         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5929         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5930         ndr_print_uint32(ndr, "priority", r->priority);
5931         ndr_print_uint32(ndr, "position", r->position);
5932         ndr_print_uint32(ndr, "start_time", r->start_time);
5933         ndr_print_uint32(ndr, "until_time", r->until_time);
5934         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5935         ndr_print_uint32(ndr, "size", r->size);
5936         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5937         ndr_print_uint32(ndr, "time", r->time);
5938         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5939         ndr_print_uint32(ndr, "size_high", r->size_high);
5940         ndr->depth--;
5941 }
5942
5943 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5944 {
5945         if (ndr_flags & NDR_SCALARS) {
5946                 int level = ndr_push_get_switch_value(ndr, r);
5947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5948                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5949                 switch (level) {
5950                         case 1: {
5951                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5952                         break; }
5953
5954                         case 2: {
5955                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5956                         break; }
5957
5958                         case 3: {
5959                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5960                         break; }
5961
5962                         case 4: {
5963                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5964                         break; }
5965
5966                         default: {
5967                         break; }
5968
5969                 }
5970         }
5971         if (ndr_flags & NDR_BUFFERS) {
5972                 int level = ndr_push_get_switch_value(ndr, r);
5973                 switch (level) {
5974                         case 1:
5975                                 if (r->info1) {
5976                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5977                                 }
5978                         break;
5979
5980                         case 2:
5981                                 if (r->info2) {
5982                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5983                                 }
5984                         break;
5985
5986                         case 3:
5987                                 if (r->info3) {
5988                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5989                                 }
5990                         break;
5991
5992                         case 4:
5993                                 if (r->info4) {
5994                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5995                                 }
5996                         break;
5997
5998                         default:
5999                         break;
6000
6001                 }
6002         }
6003         return NDR_ERR_SUCCESS;
6004 }
6005
6006 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6007 {
6008         int level;
6009         uint32_t _level;
6010         TALLOC_CTX *_mem_save_info1_0;
6011         TALLOC_CTX *_mem_save_info2_0;
6012         TALLOC_CTX *_mem_save_info3_0;
6013         TALLOC_CTX *_mem_save_info4_0;
6014         level = ndr_pull_get_switch_value(ndr, r);
6015         if (ndr_flags & NDR_SCALARS) {
6016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6017                 if (_level != level) {
6018                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6019                 }
6020                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6021                 switch (level) {
6022                         case 1: {
6023                                 uint32_t _ptr_info1;
6024                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6025                                 if (_ptr_info1) {
6026                                         NDR_PULL_ALLOC(ndr, r->info1);
6027                                 } else {
6028                                         r->info1 = NULL;
6029                                 }
6030                         break; }
6031
6032                         case 2: {
6033                                 uint32_t _ptr_info2;
6034                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6035                                 if (_ptr_info2) {
6036                                         NDR_PULL_ALLOC(ndr, r->info2);
6037                                 } else {
6038                                         r->info2 = NULL;
6039                                 }
6040                         break; }
6041
6042                         case 3: {
6043                                 uint32_t _ptr_info3;
6044                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6045                                 if (_ptr_info3) {
6046                                         NDR_PULL_ALLOC(ndr, r->info3);
6047                                 } else {
6048                                         r->info3 = NULL;
6049                                 }
6050                         break; }
6051
6052                         case 4: {
6053                                 uint32_t _ptr_info4;
6054                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6055                                 if (_ptr_info4) {
6056                                         NDR_PULL_ALLOC(ndr, r->info4);
6057                                 } else {
6058                                         r->info4 = NULL;
6059                                 }
6060                         break; }
6061
6062                         default: {
6063                         break; }
6064
6065                 }
6066         }
6067         if (ndr_flags & NDR_BUFFERS) {
6068                 switch (level) {
6069                         case 1:
6070                                 if (r->info1) {
6071                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6072                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6073                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6074                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6075                                 }
6076                         break;
6077
6078                         case 2:
6079                                 if (r->info2) {
6080                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6081                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6082                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6083                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6084                                 }
6085                         break;
6086
6087                         case 3:
6088                                 if (r->info3) {
6089                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6090                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6091                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6092                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6093                                 }
6094                         break;
6095
6096                         case 4:
6097                                 if (r->info4) {
6098                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6099                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6100                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6101                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6102                                 }
6103                         break;
6104
6105                         default:
6106                         break;
6107
6108                 }
6109         }
6110         return NDR_ERR_SUCCESS;
6111 }
6112
6113 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6114 {
6115         int level;
6116         level = ndr_print_get_switch_value(ndr, r);
6117         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6118         switch (level) {
6119                 case 1:
6120                         ndr_print_ptr(ndr, "info1", r->info1);
6121                         ndr->depth++;
6122                         if (r->info1) {
6123                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6124                         }
6125                         ndr->depth--;
6126                 break;
6127
6128                 case 2:
6129                         ndr_print_ptr(ndr, "info2", r->info2);
6130                         ndr->depth++;
6131                         if (r->info2) {
6132                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6133                         }
6134                         ndr->depth--;
6135                 break;
6136
6137                 case 3:
6138                         ndr_print_ptr(ndr, "info3", r->info3);
6139                         ndr->depth++;
6140                         if (r->info3) {
6141                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6142                         }
6143                         ndr->depth--;
6144                 break;
6145
6146                 case 4:
6147                         ndr_print_ptr(ndr, "info4", r->info4);
6148                         ndr->depth++;
6149                         if (r->info4) {
6150                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6151                         }
6152                         ndr->depth--;
6153                 break;
6154
6155                 default:
6156                 break;
6157
6158         }
6159 }
6160
6161 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6162 {
6163         if (ndr_flags & NDR_SCALARS) {
6164                 NDR_CHECK(ndr_push_align(ndr, 5));
6165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6166                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6167                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6168         }
6169         if (ndr_flags & NDR_BUFFERS) {
6170                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6171         }
6172         return NDR_ERR_SUCCESS;
6173 }
6174
6175 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6176 {
6177         if (ndr_flags & NDR_SCALARS) {
6178                 NDR_CHECK(ndr_pull_align(ndr, 5));
6179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6180                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6181                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6182         }
6183         if (ndr_flags & NDR_BUFFERS) {
6184                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6185         }
6186         return NDR_ERR_SUCCESS;
6187 }
6188
6189 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6190 {
6191         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6192         ndr->depth++;
6193         ndr_print_uint32(ndr, "level", r->level);
6194         ndr_print_set_switch_value(ndr, &r->info, r->level);
6195         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6196         ndr->depth--;
6197 }
6198
6199 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6200 {
6201         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6202         return NDR_ERR_SUCCESS;
6203 }
6204
6205 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6206 {
6207         uint32_t v;
6208         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6209         *r = v;
6210         return NDR_ERR_SUCCESS;
6211 }
6212
6213 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6214 {
6215         const char *val = NULL;
6216
6217         switch (r) {
6218                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6219                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6220                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6221                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6222                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6223                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6224                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6225                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6226                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6227         }
6228         ndr_print_enum(ndr, name, "ENUM", val, r);
6229 }
6230
6231 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6232 {
6233         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6234         return NDR_ERR_SUCCESS;
6235 }
6236
6237 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6238 {
6239         uint32_t v;
6240         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6241         *r = v;
6242         return NDR_ERR_SUCCESS;
6243 }
6244
6245 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6246 {
6247         const char *val = NULL;
6248
6249         switch (r) {
6250                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6251                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6252                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6253                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6254                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6255         }
6256         ndr_print_enum(ndr, name, "ENUM", val, r);
6257 }
6258
6259 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6260 {
6261         if (ndr_flags & NDR_SCALARS) {
6262                 NDR_CHECK(ndr_push_align(ndr, 5));
6263                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6264                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6268                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6280                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6283                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6287                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6288                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6292         }
6293         if (ndr_flags & NDR_BUFFERS) {
6294                 if (r->servername) {
6295                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6298                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6299                 }
6300                 if (r->printername) {
6301                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6302                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6304                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6305                 }
6306         }
6307         return NDR_ERR_SUCCESS;
6308 }
6309
6310 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6311 {
6312         uint32_t _ptr_servername;
6313         TALLOC_CTX *_mem_save_servername_0;
6314         uint32_t _ptr_printername;
6315         TALLOC_CTX *_mem_save_printername_0;
6316         if (ndr_flags & NDR_SCALARS) {
6317                 NDR_CHECK(ndr_pull_align(ndr, 5));
6318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6319                 if (_ptr_servername) {
6320                         NDR_PULL_ALLOC(ndr, r->servername);
6321                 } else {
6322                         r->servername = NULL;
6323                 }
6324                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6325                 if (_ptr_printername) {
6326                         NDR_PULL_ALLOC(ndr, r->printername);
6327                 } else {
6328                         r->printername = NULL;
6329                 }
6330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6333                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6345                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6348                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6352                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6353                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6357         }
6358         if (ndr_flags & NDR_BUFFERS) {
6359                 if (r->servername) {
6360                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6361                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6364                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6365                                 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));
6366                         }
6367                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6368                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6370                 }
6371                 if (r->printername) {
6372                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6373                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6374                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6375                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6376                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6377                                 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));
6378                         }
6379                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6380                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6382                 }
6383         }
6384         return NDR_ERR_SUCCESS;
6385 }
6386
6387 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6388 {
6389         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6390         ndr->depth++;
6391         ndr_print_ptr(ndr, "servername", r->servername);
6392         ndr->depth++;
6393         if (r->servername) {
6394                 ndr_print_string(ndr, "servername", r->servername);
6395         }
6396         ndr->depth--;
6397         ndr_print_ptr(ndr, "printername", r->printername);
6398         ndr->depth++;
6399         if (r->printername) {
6400                 ndr_print_string(ndr, "printername", r->printername);
6401         }
6402         ndr->depth--;
6403         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6404         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6405         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6406         ndr_print_spoolss_Time(ndr, "time", &r->time);
6407         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6408         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6409         ndr_print_uint32(ndr, "version", r->version);
6410         ndr_print_uint32(ndr, "free_build", r->free_build);
6411         ndr_print_uint32(ndr, "spooling", r->spooling);
6412         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6413         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6414         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6415         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6416         ndr_print_uint32(ndr, "job_error", r->job_error);
6417         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6418         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6419         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6420         ndr_print_uint32(ndr, "change_id", r->change_id);
6421         ndr_print_WERROR(ndr, "last_error", r->last_error);
6422         ndr_print_uint32(ndr, "status", r->status);
6423         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6424         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6425         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6426         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6427         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6428         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6429         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6430         ndr->depth--;
6431 }
6432
6433 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6434 {
6435         if (ndr_flags & NDR_SCALARS) {
6436                 NDR_CHECK(ndr_push_align(ndr, 5));
6437                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6441         }
6442         if (ndr_flags & NDR_BUFFERS) {
6443                 if (r->description) {
6444                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6446                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6447                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6448                 }
6449                 if (r->name) {
6450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6453                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6454                 }
6455                 if (r->comment) {
6456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6459                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6460                 }
6461         }
6462         return NDR_ERR_SUCCESS;
6463 }
6464
6465 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6466 {
6467         uint32_t _ptr_description;
6468         TALLOC_CTX *_mem_save_description_0;
6469         uint32_t _ptr_name;
6470         TALLOC_CTX *_mem_save_name_0;
6471         uint32_t _ptr_comment;
6472         TALLOC_CTX *_mem_save_comment_0;
6473         if (ndr_flags & NDR_SCALARS) {
6474                 NDR_CHECK(ndr_pull_align(ndr, 5));
6475                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6476                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6477                 if (_ptr_description) {
6478                         NDR_PULL_ALLOC(ndr, r->description);
6479                 } else {
6480                         r->description = NULL;
6481                 }
6482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6483                 if (_ptr_name) {
6484                         NDR_PULL_ALLOC(ndr, r->name);
6485                 } else {
6486                         r->name = NULL;
6487                 }
6488                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6489                 if (_ptr_comment) {
6490                         NDR_PULL_ALLOC(ndr, r->comment);
6491                 } else {
6492                         r->comment = NULL;
6493                 }
6494         }
6495         if (ndr_flags & NDR_BUFFERS) {
6496                 if (r->description) {
6497                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6498                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6499                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6500                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6501                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6502                                 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));
6503                         }
6504                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6505                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6507                 }
6508                 if (r->name) {
6509                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6510                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6511                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6512                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6513                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6514                                 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));
6515                         }
6516                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6517                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6519                 }
6520                 if (r->comment) {
6521                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6522                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6523                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6524                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6525                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6526                                 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));
6527                         }
6528                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6529                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6531                 }
6532         }
6533         return NDR_ERR_SUCCESS;
6534 }
6535
6536 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6537 {
6538         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6539         ndr->depth++;
6540         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6541         ndr_print_ptr(ndr, "description", r->description);
6542         ndr->depth++;
6543         if (r->description) {
6544                 ndr_print_string(ndr, "description", r->description);
6545         }
6546         ndr->depth--;
6547         ndr_print_ptr(ndr, "name", r->name);
6548         ndr->depth++;
6549         if (r->name) {
6550                 ndr_print_string(ndr, "name", r->name);
6551         }
6552         ndr->depth--;
6553         ndr_print_ptr(ndr, "comment", r->comment);
6554         ndr->depth++;
6555         if (r->comment) {
6556                 ndr_print_string(ndr, "comment", r->comment);
6557         }
6558         ndr->depth--;
6559         ndr->depth--;
6560 }
6561
6562 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6563 {
6564         if (ndr_flags & NDR_SCALARS) {
6565                 NDR_CHECK(ndr_push_align(ndr, 5));
6566                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6567                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6568                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6569                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6570                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6573                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6575                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6576                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6577                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6579                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6584                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6587         }
6588         if (ndr_flags & NDR_BUFFERS) {
6589                 if (r->servername) {
6590                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6591                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6592                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6593                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6594                 }
6595                 if (r->printername) {
6596                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6597                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6598                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6599                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6600                 }
6601                 if (r->sharename) {
6602                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6605                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6606                 }
6607                 if (r->portname) {
6608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6611                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6612                 }
6613                 if (r->drivername) {
6614                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6615                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6616                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6617                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6618                 }
6619                 if (r->comment) {
6620                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6623                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6624                 }
6625                 if (r->location) {
6626                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6629                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6630                 }
6631                 if (r->devmode) {
6632                         {
6633                                 struct ndr_push *_ndr_devmode;
6634                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6635                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6636                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6637                         }
6638                 }
6639                 if (r->sepfile) {
6640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6643                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6644                 }
6645                 if (r->printprocessor) {
6646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6649                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6650                 }
6651                 if (r->datatype) {
6652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6656                 }
6657                 if (r->parameters) {
6658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6661                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6662                 }
6663                 if (r->secdesc) {
6664                         {
6665                                 struct ndr_push *_ndr_secdesc;
6666                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6667                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6668                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6669                         }
6670                 }
6671         }
6672         return NDR_ERR_SUCCESS;
6673 }
6674
6675 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6676 {
6677         uint32_t _ptr_servername;
6678         TALLOC_CTX *_mem_save_servername_0;
6679         uint32_t _ptr_printername;
6680         TALLOC_CTX *_mem_save_printername_0;
6681         uint32_t _ptr_sharename;
6682         TALLOC_CTX *_mem_save_sharename_0;
6683         uint32_t _ptr_portname;
6684         TALLOC_CTX *_mem_save_portname_0;
6685         uint32_t _ptr_drivername;
6686         TALLOC_CTX *_mem_save_drivername_0;
6687         uint32_t _ptr_comment;
6688         TALLOC_CTX *_mem_save_comment_0;
6689         uint32_t _ptr_location;
6690         TALLOC_CTX *_mem_save_location_0;
6691         uint32_t _ptr_devmode;
6692         TALLOC_CTX *_mem_save_devmode_0;
6693         uint32_t _ptr_sepfile;
6694         TALLOC_CTX *_mem_save_sepfile_0;
6695         uint32_t _ptr_printprocessor;
6696         TALLOC_CTX *_mem_save_printprocessor_0;
6697         uint32_t _ptr_datatype;
6698         TALLOC_CTX *_mem_save_datatype_0;
6699         uint32_t _ptr_parameters;
6700         TALLOC_CTX *_mem_save_parameters_0;
6701         uint32_t _ptr_secdesc;
6702         TALLOC_CTX *_mem_save_secdesc_0;
6703         if (ndr_flags & NDR_SCALARS) {
6704                 NDR_CHECK(ndr_pull_align(ndr, 5));
6705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6706                 if (_ptr_servername) {
6707                         NDR_PULL_ALLOC(ndr, r->servername);
6708                 } else {
6709                         r->servername = NULL;
6710                 }
6711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6712                 if (_ptr_printername) {
6713                         NDR_PULL_ALLOC(ndr, r->printername);
6714                 } else {
6715                         r->printername = NULL;
6716                 }
6717                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6718                 if (_ptr_sharename) {
6719                         NDR_PULL_ALLOC(ndr, r->sharename);
6720                 } else {
6721                         r->sharename = NULL;
6722                 }
6723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6724                 if (_ptr_portname) {
6725                         NDR_PULL_ALLOC(ndr, r->portname);
6726                 } else {
6727                         r->portname = NULL;
6728                 }
6729                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6730                 if (_ptr_drivername) {
6731                         NDR_PULL_ALLOC(ndr, r->drivername);
6732                 } else {
6733                         r->drivername = NULL;
6734                 }
6735                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6736                 if (_ptr_comment) {
6737                         NDR_PULL_ALLOC(ndr, r->comment);
6738                 } else {
6739                         r->comment = NULL;
6740                 }
6741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6742                 if (_ptr_location) {
6743                         NDR_PULL_ALLOC(ndr, r->location);
6744                 } else {
6745                         r->location = NULL;
6746                 }
6747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6748                 if (_ptr_devmode) {
6749                         NDR_PULL_ALLOC(ndr, r->devmode);
6750                 } else {
6751                         r->devmode = NULL;
6752                 }
6753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6754                 if (_ptr_sepfile) {
6755                         NDR_PULL_ALLOC(ndr, r->sepfile);
6756                 } else {
6757                         r->sepfile = NULL;
6758                 }
6759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6760                 if (_ptr_printprocessor) {
6761                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6762                 } else {
6763                         r->printprocessor = NULL;
6764                 }
6765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6766                 if (_ptr_datatype) {
6767                         NDR_PULL_ALLOC(ndr, r->datatype);
6768                 } else {
6769                         r->datatype = NULL;
6770                 }
6771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6772                 if (_ptr_parameters) {
6773                         NDR_PULL_ALLOC(ndr, r->parameters);
6774                 } else {
6775                         r->parameters = NULL;
6776                 }
6777                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6778                 if (_ptr_secdesc) {
6779                         NDR_PULL_ALLOC(ndr, r->secdesc);
6780                 } else {
6781                         r->secdesc = NULL;
6782                 }
6783                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6785                 if (r->priority > 99) {
6786                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6787                 }
6788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6791                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6794         }
6795         if (ndr_flags & NDR_BUFFERS) {
6796                 if (r->servername) {
6797                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6798                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6799                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6800                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6801                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6802                                 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));
6803                         }
6804                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6805                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6806                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6807                 }
6808                 if (r->printername) {
6809                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6810                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6811                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6812                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6813                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6814                                 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));
6815                         }
6816                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6817                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6818                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6819                 }
6820                 if (r->sharename) {
6821                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6822                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6823                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6824                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6825                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6826                                 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));
6827                         }
6828                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6829                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6830                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6831                 }
6832                 if (r->portname) {
6833                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6834                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6835                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6836                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6837                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6838                                 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));
6839                         }
6840                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6841                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6842                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6843                 }
6844                 if (r->drivername) {
6845                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6846                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6847                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6848                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6849                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6850                                 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));
6851                         }
6852                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6853                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6854                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6855                 }
6856                 if (r->comment) {
6857                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6858                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6859                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6860                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6861                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6862                                 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));
6863                         }
6864                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6865                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6866                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6867                 }
6868                 if (r->location) {
6869                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6870                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6871                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6872                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6873                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6874                                 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));
6875                         }
6876                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6877                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6879                 }
6880                 if (r->devmode) {
6881                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6882                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6883                         {
6884                                 struct ndr_pull *_ndr_devmode;
6885                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6886                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6887                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6888                         }
6889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6890                 }
6891                 if (r->sepfile) {
6892                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6893                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6894                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6895                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6896                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6897                                 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));
6898                         }
6899                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6900                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6902                 }
6903                 if (r->printprocessor) {
6904                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6905                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6906                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6907                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6908                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6909                                 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));
6910                         }
6911                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6912                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6914                 }
6915                 if (r->datatype) {
6916                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6917                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6918                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6919                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6920                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6921                                 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));
6922                         }
6923                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6924                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6926                 }
6927                 if (r->parameters) {
6928                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6929                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6931                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6932                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6933                                 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));
6934                         }
6935                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6936                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6938                 }
6939                 if (r->secdesc) {
6940                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6941                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6942                         {
6943                                 struct ndr_pull *_ndr_secdesc;
6944                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6945                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6946                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6947                         }
6948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6949                 }
6950         }
6951         return NDR_ERR_SUCCESS;
6952 }
6953
6954 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6955 {
6956         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6957         ndr->depth++;
6958         ndr_print_ptr(ndr, "servername", r->servername);
6959         ndr->depth++;
6960         if (r->servername) {
6961                 ndr_print_string(ndr, "servername", r->servername);
6962         }
6963         ndr->depth--;
6964         ndr_print_ptr(ndr, "printername", r->printername);
6965         ndr->depth++;
6966         if (r->printername) {
6967                 ndr_print_string(ndr, "printername", r->printername);
6968         }
6969         ndr->depth--;
6970         ndr_print_ptr(ndr, "sharename", r->sharename);
6971         ndr->depth++;
6972         if (r->sharename) {
6973                 ndr_print_string(ndr, "sharename", r->sharename);
6974         }
6975         ndr->depth--;
6976         ndr_print_ptr(ndr, "portname", r->portname);
6977         ndr->depth++;
6978         if (r->portname) {
6979                 ndr_print_string(ndr, "portname", r->portname);
6980         }
6981         ndr->depth--;
6982         ndr_print_ptr(ndr, "drivername", r->drivername);
6983         ndr->depth++;
6984         if (r->drivername) {
6985                 ndr_print_string(ndr, "drivername", r->drivername);
6986         }
6987         ndr->depth--;
6988         ndr_print_ptr(ndr, "comment", r->comment);
6989         ndr->depth++;
6990         if (r->comment) {
6991                 ndr_print_string(ndr, "comment", r->comment);
6992         }
6993         ndr->depth--;
6994         ndr_print_ptr(ndr, "location", r->location);
6995         ndr->depth++;
6996         if (r->location) {
6997                 ndr_print_string(ndr, "location", r->location);
6998         }
6999         ndr->depth--;
7000         ndr_print_ptr(ndr, "devmode", r->devmode);
7001         ndr->depth++;
7002         if (r->devmode) {
7003                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
7004         }
7005         ndr->depth--;
7006         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7007         ndr->depth++;
7008         if (r->sepfile) {
7009                 ndr_print_string(ndr, "sepfile", r->sepfile);
7010         }
7011         ndr->depth--;
7012         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7013         ndr->depth++;
7014         if (r->printprocessor) {
7015                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7016         }
7017         ndr->depth--;
7018         ndr_print_ptr(ndr, "datatype", r->datatype);
7019         ndr->depth++;
7020         if (r->datatype) {
7021                 ndr_print_string(ndr, "datatype", r->datatype);
7022         }
7023         ndr->depth--;
7024         ndr_print_ptr(ndr, "parameters", r->parameters);
7025         ndr->depth++;
7026         if (r->parameters) {
7027                 ndr_print_string(ndr, "parameters", r->parameters);
7028         }
7029         ndr->depth--;
7030         ndr_print_ptr(ndr, "secdesc", r->secdesc);
7031         ndr->depth++;
7032         if (r->secdesc) {
7033                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
7034         }
7035         ndr->depth--;
7036         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7037         ndr_print_uint32(ndr, "priority", r->priority);
7038         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7039         ndr_print_uint32(ndr, "starttime", r->starttime);
7040         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7041         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7042         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7043         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7044         ndr->depth--;
7045 }
7046
7047 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7048 {
7049         if (ndr_flags & NDR_SCALARS) {
7050                 NDR_CHECK(ndr_push_align(ndr, 4));
7051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7052         }
7053         if (ndr_flags & NDR_BUFFERS) {
7054         }
7055         return NDR_ERR_SUCCESS;
7056 }
7057
7058 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7059 {
7060         if (ndr_flags & NDR_SCALARS) {
7061                 NDR_CHECK(ndr_pull_align(ndr, 4));
7062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7063         }
7064         if (ndr_flags & NDR_BUFFERS) {
7065         }
7066         return NDR_ERR_SUCCESS;
7067 }
7068
7069 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7070 {
7071         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7072         ndr->depth++;
7073         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7074         ndr->depth--;
7075 }
7076
7077 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7078 {
7079         if (ndr_flags & NDR_SCALARS) {
7080                 NDR_CHECK(ndr_push_align(ndr, 5));
7081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7082                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7083                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7084         }
7085         if (ndr_flags & NDR_BUFFERS) {
7086                 if (r->printername) {
7087                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7088                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7091                 }
7092                 if (r->servername) {
7093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7095                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7097                 }
7098         }
7099         return NDR_ERR_SUCCESS;
7100 }
7101
7102 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7103 {
7104         uint32_t _ptr_printername;
7105         TALLOC_CTX *_mem_save_printername_0;
7106         uint32_t _ptr_servername;
7107         TALLOC_CTX *_mem_save_servername_0;
7108         if (ndr_flags & NDR_SCALARS) {
7109                 NDR_CHECK(ndr_pull_align(ndr, 5));
7110                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7111                 if (_ptr_printername) {
7112                         NDR_PULL_ALLOC(ndr, r->printername);
7113                 } else {
7114                         r->printername = NULL;
7115                 }
7116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7117                 if (_ptr_servername) {
7118                         NDR_PULL_ALLOC(ndr, r->servername);
7119                 } else {
7120                         r->servername = NULL;
7121                 }
7122                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7123         }
7124         if (ndr_flags & NDR_BUFFERS) {
7125                 if (r->printername) {
7126                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7127                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7130                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7131                                 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));
7132                         }
7133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7136                 }
7137                 if (r->servername) {
7138                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7139                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7140                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7141                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7142                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7143                                 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));
7144                         }
7145                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7146                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7148                 }
7149         }
7150         return NDR_ERR_SUCCESS;
7151 }
7152
7153 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7154 {
7155         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7156         ndr->depth++;
7157         ndr_print_ptr(ndr, "printername", r->printername);
7158         ndr->depth++;
7159         if (r->printername) {
7160                 ndr_print_string(ndr, "printername", r->printername);
7161         }
7162         ndr->depth--;
7163         ndr_print_ptr(ndr, "servername", r->servername);
7164         ndr->depth++;
7165         if (r->servername) {
7166                 ndr_print_string(ndr, "servername", r->servername);
7167         }
7168         ndr->depth--;
7169         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7170         ndr->depth--;
7171 }
7172
7173 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7174 {
7175         if (ndr_flags & NDR_SCALARS) {
7176                 NDR_CHECK(ndr_push_align(ndr, 5));
7177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7178                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7179                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7182         }
7183         if (ndr_flags & NDR_BUFFERS) {
7184                 if (r->printername) {
7185                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7186                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7188                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7189                 }
7190                 if (r->portname) {
7191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7194                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7195                 }
7196         }
7197         return NDR_ERR_SUCCESS;
7198 }
7199
7200 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7201 {
7202         uint32_t _ptr_printername;
7203         TALLOC_CTX *_mem_save_printername_0;
7204         uint32_t _ptr_portname;
7205         TALLOC_CTX *_mem_save_portname_0;
7206         if (ndr_flags & NDR_SCALARS) {
7207                 NDR_CHECK(ndr_pull_align(ndr, 5));
7208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7209                 if (_ptr_printername) {
7210                         NDR_PULL_ALLOC(ndr, r->printername);
7211                 } else {
7212                         r->printername = NULL;
7213                 }
7214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7215                 if (_ptr_portname) {
7216                         NDR_PULL_ALLOC(ndr, r->portname);
7217                 } else {
7218                         r->portname = NULL;
7219                 }
7220                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7223         }
7224         if (ndr_flags & NDR_BUFFERS) {
7225                 if (r->printername) {
7226                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7227                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7228                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7229                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7230                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7231                                 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));
7232                         }
7233                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7234                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7235                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7236                 }
7237                 if (r->portname) {
7238                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7239                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7240                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7241                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7242                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7243                                 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));
7244                         }
7245                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7246                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7247                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7248                 }
7249         }
7250         return NDR_ERR_SUCCESS;
7251 }
7252
7253 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7254 {
7255         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7256         ndr->depth++;
7257         ndr_print_ptr(ndr, "printername", r->printername);
7258         ndr->depth++;
7259         if (r->printername) {
7260                 ndr_print_string(ndr, "printername", r->printername);
7261         }
7262         ndr->depth--;
7263         ndr_print_ptr(ndr, "portname", r->portname);
7264         ndr->depth++;
7265         if (r->portname) {
7266                 ndr_print_string(ndr, "portname", r->portname);
7267         }
7268         ndr->depth--;
7269         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7270         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7271         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7272         ndr->depth--;
7273 }
7274
7275 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7276 {
7277         if (ndr_flags & NDR_SCALARS) {
7278                 NDR_CHECK(ndr_push_align(ndr, 4));
7279                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7280         }
7281         if (ndr_flags & NDR_BUFFERS) {
7282         }
7283         return NDR_ERR_SUCCESS;
7284 }
7285
7286 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7287 {
7288         if (ndr_flags & NDR_SCALARS) {
7289                 NDR_CHECK(ndr_pull_align(ndr, 4));
7290                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7291         }
7292         if (ndr_flags & NDR_BUFFERS) {
7293         }
7294         return NDR_ERR_SUCCESS;
7295 }
7296
7297 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7298 {
7299         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7300         ndr->depth++;
7301         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7302         ndr->depth--;
7303 }
7304
7305 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7306 {
7307         if (ndr_flags & NDR_SCALARS) {
7308                 NDR_CHECK(ndr_push_align(ndr, 5));
7309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7310                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7311         }
7312         if (ndr_flags & NDR_BUFFERS) {
7313                 if (r->guid) {
7314                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7317                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7318                 }
7319         }
7320         return NDR_ERR_SUCCESS;
7321 }
7322
7323 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7324 {
7325         uint32_t _ptr_guid;
7326         TALLOC_CTX *_mem_save_guid_0;
7327         if (ndr_flags & NDR_SCALARS) {
7328                 NDR_CHECK(ndr_pull_align(ndr, 5));
7329                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7330                 if (_ptr_guid) {
7331                         NDR_PULL_ALLOC(ndr, r->guid);
7332                 } else {
7333                         r->guid = NULL;
7334                 }
7335                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7336         }
7337         if (ndr_flags & NDR_BUFFERS) {
7338                 if (r->guid) {
7339                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7340                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7343                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7344                                 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));
7345                         }
7346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7349                 }
7350         }
7351         return NDR_ERR_SUCCESS;
7352 }
7353
7354 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7355 {
7356         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7357         ndr->depth++;
7358         ndr_print_ptr(ndr, "guid", r->guid);
7359         ndr->depth++;
7360         if (r->guid) {
7361                 ndr_print_string(ndr, "guid", r->guid);
7362         }
7363         ndr->depth--;
7364         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7365         ndr->depth--;
7366 }
7367
7368 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7369 {
7370         if (ndr_flags & NDR_SCALARS) {
7371                 int level = ndr_push_get_switch_value(ndr, r);
7372                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7373                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7374                 switch (level) {
7375                         case 0: {
7376                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7377                         break; }
7378
7379                         case 1: {
7380                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7381                         break; }
7382
7383                         case 2: {
7384                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7385                         break; }
7386
7387                         case 3: {
7388                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7389                         break; }
7390
7391                         case 4: {
7392                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7393                         break; }
7394
7395                         case 5: {
7396                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7397                         break; }
7398
7399                         case 6: {
7400                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7401                         break; }
7402
7403                         case 7: {
7404                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7405                         break; }
7406
7407                         case 8: {
7408                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7409                         break; }
7410
7411                         case 9: {
7412                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7413                         break; }
7414
7415                         default: {
7416                         break; }
7417
7418                 }
7419         }
7420         if (ndr_flags & NDR_BUFFERS) {
7421                 int level = ndr_push_get_switch_value(ndr, r);
7422                 switch (level) {
7423                         case 0:
7424                                 if (r->info0) {
7425                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7426                                 }
7427                         break;
7428
7429                         case 1:
7430                                 if (r->info1) {
7431                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7432                                 }
7433                         break;
7434
7435                         case 2:
7436                                 if (r->info2) {
7437                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7438                                 }
7439                         break;
7440
7441                         case 3:
7442                                 if (r->info3) {
7443                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7444                                 }
7445                         break;
7446
7447                         case 4:
7448                                 if (r->info4) {
7449                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7450                                 }
7451                         break;
7452
7453                         case 5:
7454                                 if (r->info5) {
7455                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7456                                 }
7457                         break;
7458
7459                         case 6:
7460                                 if (r->info6) {
7461                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7462                                 }
7463                         break;
7464
7465                         case 7:
7466                                 if (r->info7) {
7467                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7468                                 }
7469                         break;
7470
7471                         case 8:
7472                                 if (r->info8) {
7473                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7474                                 }
7475                         break;
7476
7477                         case 9:
7478                                 if (r->info9) {
7479                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7480                                 }
7481                         break;
7482
7483                         default:
7484                         break;
7485
7486                 }
7487         }
7488         return NDR_ERR_SUCCESS;
7489 }
7490
7491 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7492 {
7493         int level;
7494         uint32_t _level;
7495         TALLOC_CTX *_mem_save_info0_0;
7496         TALLOC_CTX *_mem_save_info1_0;
7497         TALLOC_CTX *_mem_save_info2_0;
7498         TALLOC_CTX *_mem_save_info3_0;
7499         TALLOC_CTX *_mem_save_info4_0;
7500         TALLOC_CTX *_mem_save_info5_0;
7501         TALLOC_CTX *_mem_save_info6_0;
7502         TALLOC_CTX *_mem_save_info7_0;
7503         TALLOC_CTX *_mem_save_info8_0;
7504         TALLOC_CTX *_mem_save_info9_0;
7505         level = ndr_pull_get_switch_value(ndr, r);
7506         if (ndr_flags & NDR_SCALARS) {
7507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7508                 if (_level != level) {
7509                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7510                 }
7511                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7512                 switch (level) {
7513                         case 0: {
7514                                 uint32_t _ptr_info0;
7515                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7516                                 if (_ptr_info0) {
7517                                         NDR_PULL_ALLOC(ndr, r->info0);
7518                                 } else {
7519                                         r->info0 = NULL;
7520                                 }
7521                         break; }
7522
7523                         case 1: {
7524                                 uint32_t _ptr_info1;
7525                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7526                                 if (_ptr_info1) {
7527                                         NDR_PULL_ALLOC(ndr, r->info1);
7528                                 } else {
7529                                         r->info1 = NULL;
7530                                 }
7531                         break; }
7532
7533                         case 2: {
7534                                 uint32_t _ptr_info2;
7535                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7536                                 if (_ptr_info2) {
7537                                         NDR_PULL_ALLOC(ndr, r->info2);
7538                                 } else {
7539                                         r->info2 = NULL;
7540                                 }
7541                         break; }
7542
7543                         case 3: {
7544                                 uint32_t _ptr_info3;
7545                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7546                                 if (_ptr_info3) {
7547                                         NDR_PULL_ALLOC(ndr, r->info3);
7548                                 } else {
7549                                         r->info3 = NULL;
7550                                 }
7551                         break; }
7552
7553                         case 4: {
7554                                 uint32_t _ptr_info4;
7555                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7556                                 if (_ptr_info4) {
7557                                         NDR_PULL_ALLOC(ndr, r->info4);
7558                                 } else {
7559                                         r->info4 = NULL;
7560                                 }
7561                         break; }
7562
7563                         case 5: {
7564                                 uint32_t _ptr_info5;
7565                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7566                                 if (_ptr_info5) {
7567                                         NDR_PULL_ALLOC(ndr, r->info5);
7568                                 } else {
7569                                         r->info5 = NULL;
7570                                 }
7571                         break; }
7572
7573                         case 6: {
7574                                 uint32_t _ptr_info6;
7575                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7576                                 if (_ptr_info6) {
7577                                         NDR_PULL_ALLOC(ndr, r->info6);
7578                                 } else {
7579                                         r->info6 = NULL;
7580                                 }
7581                         break; }
7582
7583                         case 7: {
7584                                 uint32_t _ptr_info7;
7585                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7586                                 if (_ptr_info7) {
7587                                         NDR_PULL_ALLOC(ndr, r->info7);
7588                                 } else {
7589                                         r->info7 = NULL;
7590                                 }
7591                         break; }
7592
7593                         case 8: {
7594                                 uint32_t _ptr_info8;
7595                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7596                                 if (_ptr_info8) {
7597                                         NDR_PULL_ALLOC(ndr, r->info8);
7598                                 } else {
7599                                         r->info8 = NULL;
7600                                 }
7601                         break; }
7602
7603                         case 9: {
7604                                 uint32_t _ptr_info9;
7605                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7606                                 if (_ptr_info9) {
7607                                         NDR_PULL_ALLOC(ndr, r->info9);
7608                                 } else {
7609                                         r->info9 = NULL;
7610                                 }
7611                         break; }
7612
7613                         default: {
7614                         break; }
7615
7616                 }
7617         }
7618         if (ndr_flags & NDR_BUFFERS) {
7619                 switch (level) {
7620                         case 0:
7621                                 if (r->info0) {
7622                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7623                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7624                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7625                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7626                                 }
7627                         break;
7628
7629                         case 1:
7630                                 if (r->info1) {
7631                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7632                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7633                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7634                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7635                                 }
7636                         break;
7637
7638                         case 2:
7639                                 if (r->info2) {
7640                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7641                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7642                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7643                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7644                                 }
7645                         break;
7646
7647                         case 3:
7648                                 if (r->info3) {
7649                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7650                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7651                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7652                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7653                                 }
7654                         break;
7655
7656                         case 4:
7657                                 if (r->info4) {
7658                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7659                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7660                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7661                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7662                                 }
7663                         break;
7664
7665                         case 5:
7666                                 if (r->info5) {
7667                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7668                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7669                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7670                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7671                                 }
7672                         break;
7673
7674                         case 6:
7675                                 if (r->info6) {
7676                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7677                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7678                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7679                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7680                                 }
7681                         break;
7682
7683                         case 7:
7684                                 if (r->info7) {
7685                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7686                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7687                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7688                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7689                                 }
7690                         break;
7691
7692                         case 8:
7693                                 if (r->info8) {
7694                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7695                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7696                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7697                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7698                                 }
7699                         break;
7700
7701                         case 9:
7702                                 if (r->info9) {
7703                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7704                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7705                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7706                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7707                                 }
7708                         break;
7709
7710                         default:
7711                         break;
7712
7713                 }
7714         }
7715         return NDR_ERR_SUCCESS;
7716 }
7717
7718 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7719 {
7720         int level;
7721         level = ndr_print_get_switch_value(ndr, r);
7722         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7723         switch (level) {
7724                 case 0:
7725                         ndr_print_ptr(ndr, "info0", r->info0);
7726                         ndr->depth++;
7727                         if (r->info0) {
7728                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7729                         }
7730                         ndr->depth--;
7731                 break;
7732
7733                 case 1:
7734                         ndr_print_ptr(ndr, "info1", r->info1);
7735                         ndr->depth++;
7736                         if (r->info1) {
7737                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7738                         }
7739                         ndr->depth--;
7740                 break;
7741
7742                 case 2:
7743                         ndr_print_ptr(ndr, "info2", r->info2);
7744                         ndr->depth++;
7745                         if (r->info2) {
7746                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7747                         }
7748                         ndr->depth--;
7749                 break;
7750
7751                 case 3:
7752                         ndr_print_ptr(ndr, "info3", r->info3);
7753                         ndr->depth++;
7754                         if (r->info3) {
7755                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7756                         }
7757                         ndr->depth--;
7758                 break;
7759
7760                 case 4:
7761                         ndr_print_ptr(ndr, "info4", r->info4);
7762                         ndr->depth++;
7763                         if (r->info4) {
7764                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7765                         }
7766                         ndr->depth--;
7767                 break;
7768
7769                 case 5:
7770                         ndr_print_ptr(ndr, "info5", r->info5);
7771                         ndr->depth++;
7772                         if (r->info5) {
7773                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7774                         }
7775                         ndr->depth--;
7776                 break;
7777
7778                 case 6:
7779                         ndr_print_ptr(ndr, "info6", r->info6);
7780                         ndr->depth++;
7781                         if (r->info6) {
7782                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7783                         }
7784                         ndr->depth--;
7785                 break;
7786
7787                 case 7:
7788                         ndr_print_ptr(ndr, "info7", r->info7);
7789                         ndr->depth++;
7790                         if (r->info7) {
7791                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7792                         }
7793                         ndr->depth--;
7794                 break;
7795
7796                 case 8:
7797                         ndr_print_ptr(ndr, "info8", r->info8);
7798                         ndr->depth++;
7799                         if (r->info8) {
7800                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7801                         }
7802                         ndr->depth--;
7803                 break;
7804
7805                 case 9:
7806                         ndr_print_ptr(ndr, "info9", r->info9);
7807                         ndr->depth++;
7808                         if (r->info9) {
7809                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7810                         }
7811                         ndr->depth--;
7812                 break;
7813
7814                 default:
7815                 break;
7816
7817         }
7818 }
7819
7820 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7821 {
7822         if (ndr_flags & NDR_SCALARS) {
7823                 NDR_CHECK(ndr_push_align(ndr, 5));
7824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7825                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7826                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7827         }
7828         if (ndr_flags & NDR_BUFFERS) {
7829                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7830         }
7831         return NDR_ERR_SUCCESS;
7832 }
7833
7834 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7835 {
7836         if (ndr_flags & NDR_SCALARS) {
7837                 NDR_CHECK(ndr_pull_align(ndr, 5));
7838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7839                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7840                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7841         }
7842         if (ndr_flags & NDR_BUFFERS) {
7843                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7844         }
7845         return NDR_ERR_SUCCESS;
7846 }
7847
7848 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7849 {
7850         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7851         ndr->depth++;
7852         ndr_print_uint32(ndr, "level", r->level);
7853         ndr_print_set_switch_value(ndr, &r->info, r->level);
7854         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7855         ndr->depth--;
7856 }
7857
7858 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7859 {
7860         if (ndr_flags & NDR_SCALARS) {
7861                 NDR_CHECK(ndr_push_align(ndr, 4));
7862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7863                 {
7864                         uint32_t _flags_save_string_array = ndr->flags;
7865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7866                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7867                         ndr->flags = _flags_save_string_array;
7868                 }
7869         }
7870         if (ndr_flags & NDR_BUFFERS) {
7871         }
7872         return NDR_ERR_SUCCESS;
7873 }
7874
7875 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7876 {
7877         if (ndr_flags & NDR_SCALARS) {
7878                 NDR_CHECK(ndr_pull_align(ndr, 4));
7879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7880                 {
7881                         uint32_t _flags_save_string_array = ndr->flags;
7882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7883                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7884                         ndr->flags = _flags_save_string_array;
7885                 }
7886         }
7887         if (ndr_flags & NDR_BUFFERS) {
7888         }
7889         return NDR_ERR_SUCCESS;
7890 }
7891
7892 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7893 {
7894         ndr_print_struct(ndr, name, "spoolss_StringArray");
7895         ndr->depth++;
7896         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);
7897         ndr_print_string_array(ndr, "string", r->string);
7898         ndr->depth--;
7899 }
7900
7901 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7902 {
7903         if (ndr_flags & NDR_SCALARS) {
7904                 NDR_CHECK(ndr_push_align(ndr, 5));
7905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7906         }
7907         if (ndr_flags & NDR_BUFFERS) {
7908                 if (r->driver_name) {
7909                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7910                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7911                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7913                 }
7914         }
7915         return NDR_ERR_SUCCESS;
7916 }
7917
7918 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7919 {
7920         uint32_t _ptr_driver_name;
7921         TALLOC_CTX *_mem_save_driver_name_0;
7922         if (ndr_flags & NDR_SCALARS) {
7923                 NDR_CHECK(ndr_pull_align(ndr, 5));
7924                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7925                 if (_ptr_driver_name) {
7926                         NDR_PULL_ALLOC(ndr, r->driver_name);
7927                 } else {
7928                         r->driver_name = NULL;
7929                 }
7930         }
7931         if (ndr_flags & NDR_BUFFERS) {
7932                 if (r->driver_name) {
7933                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7934                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7937                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7938                                 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));
7939                         }
7940                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7941                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7943                 }
7944         }
7945         return NDR_ERR_SUCCESS;
7946 }
7947
7948 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7949 {
7950         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7951         ndr->depth++;
7952         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7953         ndr->depth++;
7954         if (r->driver_name) {
7955                 ndr_print_string(ndr, "driver_name", r->driver_name);
7956         }
7957         ndr->depth--;
7958         ndr->depth--;
7959 }
7960
7961 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7962 {
7963         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
7964         return NDR_ERR_SUCCESS;
7965 }
7966
7967 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7968 {
7969         uint32_t v;
7970         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
7971         *r = v;
7972         return NDR_ERR_SUCCESS;
7973 }
7974
7975 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7976 {
7977         const char *val = NULL;
7978
7979         switch (r) {
7980                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7981                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7982                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7983                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7984         }
7985         ndr_print_enum(ndr, name, "ENUM", val, r);
7986 }
7987
7988 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7989 {
7990         if (ndr_flags & NDR_SCALARS) {
7991                 NDR_CHECK(ndr_push_align(ndr, 5));
7992                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7994                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7996                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7998         }
7999         if (ndr_flags & NDR_BUFFERS) {
8000                 if (r->driver_name) {
8001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8002                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8004                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8005                 }
8006                 if (r->architecture) {
8007                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8008                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8009                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8010                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8011                 }
8012                 if (r->driver_path) {
8013                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8014                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8015                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8016                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8017                 }
8018                 if (r->data_file) {
8019                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8020                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8021                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8022                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8023                 }
8024                 if (r->config_file) {
8025                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8029                 }
8030         }
8031         return NDR_ERR_SUCCESS;
8032 }
8033
8034 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8035 {
8036         uint32_t _ptr_driver_name;
8037         TALLOC_CTX *_mem_save_driver_name_0;
8038         uint32_t _ptr_architecture;
8039         TALLOC_CTX *_mem_save_architecture_0;
8040         uint32_t _ptr_driver_path;
8041         TALLOC_CTX *_mem_save_driver_path_0;
8042         uint32_t _ptr_data_file;
8043         TALLOC_CTX *_mem_save_data_file_0;
8044         uint32_t _ptr_config_file;
8045         TALLOC_CTX *_mem_save_config_file_0;
8046         if (ndr_flags & NDR_SCALARS) {
8047                 NDR_CHECK(ndr_pull_align(ndr, 5));
8048                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8049                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8050                 if (_ptr_driver_name) {
8051                         NDR_PULL_ALLOC(ndr, r->driver_name);
8052                 } else {
8053                         r->driver_name = NULL;
8054                 }
8055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8056                 if (_ptr_architecture) {
8057                         NDR_PULL_ALLOC(ndr, r->architecture);
8058                 } else {
8059                         r->architecture = NULL;
8060                 }
8061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8062                 if (_ptr_driver_path) {
8063                         NDR_PULL_ALLOC(ndr, r->driver_path);
8064                 } else {
8065                         r->driver_path = NULL;
8066                 }
8067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8068                 if (_ptr_data_file) {
8069                         NDR_PULL_ALLOC(ndr, r->data_file);
8070                 } else {
8071                         r->data_file = NULL;
8072                 }
8073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8074                 if (_ptr_config_file) {
8075                         NDR_PULL_ALLOC(ndr, r->config_file);
8076                 } else {
8077                         r->config_file = NULL;
8078                 }
8079         }
8080         if (ndr_flags & NDR_BUFFERS) {
8081                 if (r->driver_name) {
8082                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8083                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8086                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8087                                 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));
8088                         }
8089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8092                 }
8093                 if (r->architecture) {
8094                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8095                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8096                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8097                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8098                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8099                                 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));
8100                         }
8101                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8102                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8104                 }
8105                 if (r->driver_path) {
8106                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8107                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8109                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8110                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8111                                 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));
8112                         }
8113                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8114                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8116                 }
8117                 if (r->data_file) {
8118                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8119                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8121                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8122                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8123                                 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));
8124                         }
8125                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8126                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8128                 }
8129                 if (r->config_file) {
8130                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8131                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8132                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8133                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8134                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8135                                 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));
8136                         }
8137                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8138                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8140                 }
8141         }
8142         return NDR_ERR_SUCCESS;
8143 }
8144
8145 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8146 {
8147         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8148         ndr->depth++;
8149         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8150         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8151         ndr->depth++;
8152         if (r->driver_name) {
8153                 ndr_print_string(ndr, "driver_name", r->driver_name);
8154         }
8155         ndr->depth--;
8156         ndr_print_ptr(ndr, "architecture", r->architecture);
8157         ndr->depth++;
8158         if (r->architecture) {
8159                 ndr_print_string(ndr, "architecture", r->architecture);
8160         }
8161         ndr->depth--;
8162         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8163         ndr->depth++;
8164         if (r->driver_path) {
8165                 ndr_print_string(ndr, "driver_path", r->driver_path);
8166         }
8167         ndr->depth--;
8168         ndr_print_ptr(ndr, "data_file", r->data_file);
8169         ndr->depth++;
8170         if (r->data_file) {
8171                 ndr_print_string(ndr, "data_file", r->data_file);
8172         }
8173         ndr->depth--;
8174         ndr_print_ptr(ndr, "config_file", r->config_file);
8175         ndr->depth++;
8176         if (r->config_file) {
8177                 ndr_print_string(ndr, "config_file", r->config_file);
8178         }
8179         ndr->depth--;
8180         ndr->depth--;
8181 }
8182
8183 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8184 {
8185         if (ndr_flags & NDR_SCALARS) {
8186                 NDR_CHECK(ndr_push_align(ndr, 5));
8187                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8190                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8198         }
8199         if (ndr_flags & NDR_BUFFERS) {
8200                 if (r->driver_name) {
8201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8203                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8204                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8205                 }
8206                 if (r->architecture) {
8207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8210                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8211                 }
8212                 if (r->driver_path) {
8213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8216                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8217                 }
8218                 if (r->data_file) {
8219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8220                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8221                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8222                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8223                 }
8224                 if (r->config_file) {
8225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8226                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8227                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8228                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8229                 }
8230                 if (r->help_file) {
8231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8234                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8235                 }
8236                 if (r->monitor_name) {
8237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8240                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8241                 }
8242                 if (r->default_datatype) {
8243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8244                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8246                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8247                 }
8248                 if (r->dependent_files) {
8249                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8250                 }
8251         }
8252         return NDR_ERR_SUCCESS;
8253 }
8254
8255 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8256 {
8257         uint32_t _ptr_driver_name;
8258         TALLOC_CTX *_mem_save_driver_name_0;
8259         uint32_t _ptr_architecture;
8260         TALLOC_CTX *_mem_save_architecture_0;
8261         uint32_t _ptr_driver_path;
8262         TALLOC_CTX *_mem_save_driver_path_0;
8263         uint32_t _ptr_data_file;
8264         TALLOC_CTX *_mem_save_data_file_0;
8265         uint32_t _ptr_config_file;
8266         TALLOC_CTX *_mem_save_config_file_0;
8267         uint32_t _ptr_help_file;
8268         TALLOC_CTX *_mem_save_help_file_0;
8269         uint32_t _ptr_monitor_name;
8270         TALLOC_CTX *_mem_save_monitor_name_0;
8271         uint32_t _ptr_default_datatype;
8272         TALLOC_CTX *_mem_save_default_datatype_0;
8273         uint32_t _ptr_dependent_files;
8274         TALLOC_CTX *_mem_save_dependent_files_0;
8275         if (ndr_flags & NDR_SCALARS) {
8276                 NDR_CHECK(ndr_pull_align(ndr, 5));
8277                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8279                 if (_ptr_driver_name) {
8280                         NDR_PULL_ALLOC(ndr, r->driver_name);
8281                 } else {
8282                         r->driver_name = NULL;
8283                 }
8284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8285                 if (_ptr_architecture) {
8286                         NDR_PULL_ALLOC(ndr, r->architecture);
8287                 } else {
8288                         r->architecture = NULL;
8289                 }
8290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8291                 if (_ptr_driver_path) {
8292                         NDR_PULL_ALLOC(ndr, r->driver_path);
8293                 } else {
8294                         r->driver_path = NULL;
8295                 }
8296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8297                 if (_ptr_data_file) {
8298                         NDR_PULL_ALLOC(ndr, r->data_file);
8299                 } else {
8300                         r->data_file = NULL;
8301                 }
8302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8303                 if (_ptr_config_file) {
8304                         NDR_PULL_ALLOC(ndr, r->config_file);
8305                 } else {
8306                         r->config_file = NULL;
8307                 }
8308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8309                 if (_ptr_help_file) {
8310                         NDR_PULL_ALLOC(ndr, r->help_file);
8311                 } else {
8312                         r->help_file = NULL;
8313                 }
8314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8315                 if (_ptr_monitor_name) {
8316                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8317                 } else {
8318                         r->monitor_name = NULL;
8319                 }
8320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8321                 if (_ptr_default_datatype) {
8322                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8323                 } else {
8324                         r->default_datatype = NULL;
8325                 }
8326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8327                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8328                 if (_ptr_dependent_files) {
8329                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8330                 } else {
8331                         r->dependent_files = NULL;
8332                 }
8333         }
8334         if (ndr_flags & NDR_BUFFERS) {
8335                 if (r->driver_name) {
8336                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8337                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8338                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8339                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8340                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8341                                 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));
8342                         }
8343                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8344                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8346                 }
8347                 if (r->architecture) {
8348                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8349                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8350                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8351                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8352                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8353                                 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));
8354                         }
8355                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8356                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8357                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8358                 }
8359                 if (r->driver_path) {
8360                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8361                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8364                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8365                                 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));
8366                         }
8367                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8368                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8370                 }
8371                 if (r->data_file) {
8372                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8373                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8374                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8375                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8376                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8377                                 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));
8378                         }
8379                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8380                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8382                 }
8383                 if (r->config_file) {
8384                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8385                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8387                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8388                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8389                                 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));
8390                         }
8391                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8392                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8394                 }
8395                 if (r->help_file) {
8396                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8397                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8398                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8399                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8400                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8401                                 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));
8402                         }
8403                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8404                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8406                 }
8407                 if (r->monitor_name) {
8408                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8409                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8410                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8411                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8412                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8413                                 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));
8414                         }
8415                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8416                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8418                 }
8419                 if (r->default_datatype) {
8420                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8421                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8422                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8423                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8424                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8425                                 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));
8426                         }
8427                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8428                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8430                 }
8431                 if (r->dependent_files) {
8432                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8433                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8434                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8436                 }
8437         }
8438         return NDR_ERR_SUCCESS;
8439 }
8440
8441 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8442 {
8443         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8444         ndr->depth++;
8445         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8446         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8447         ndr->depth++;
8448         if (r->driver_name) {
8449                 ndr_print_string(ndr, "driver_name", r->driver_name);
8450         }
8451         ndr->depth--;
8452         ndr_print_ptr(ndr, "architecture", r->architecture);
8453         ndr->depth++;
8454         if (r->architecture) {
8455                 ndr_print_string(ndr, "architecture", r->architecture);
8456         }
8457         ndr->depth--;
8458         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8459         ndr->depth++;
8460         if (r->driver_path) {
8461                 ndr_print_string(ndr, "driver_path", r->driver_path);
8462         }
8463         ndr->depth--;
8464         ndr_print_ptr(ndr, "data_file", r->data_file);
8465         ndr->depth++;
8466         if (r->data_file) {
8467                 ndr_print_string(ndr, "data_file", r->data_file);
8468         }
8469         ndr->depth--;
8470         ndr_print_ptr(ndr, "config_file", r->config_file);
8471         ndr->depth++;
8472         if (r->config_file) {
8473                 ndr_print_string(ndr, "config_file", r->config_file);
8474         }
8475         ndr->depth--;
8476         ndr_print_ptr(ndr, "help_file", r->help_file);
8477         ndr->depth++;
8478         if (r->help_file) {
8479                 ndr_print_string(ndr, "help_file", r->help_file);
8480         }
8481         ndr->depth--;
8482         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8483         ndr->depth++;
8484         if (r->monitor_name) {
8485                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8486         }
8487         ndr->depth--;
8488         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8489         ndr->depth++;
8490         if (r->default_datatype) {
8491                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8492         }
8493         ndr->depth--;
8494         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);
8495         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8496         ndr->depth++;
8497         if (r->dependent_files) {
8498                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8499         }
8500         ndr->depth--;
8501         ndr->depth--;
8502 }
8503
8504 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8505 {
8506         if (ndr_flags & NDR_SCALARS) {
8507                 NDR_CHECK(ndr_push_align(ndr, 5));
8508                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8509                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8510                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8521         }
8522         if (ndr_flags & NDR_BUFFERS) {
8523                 if (r->driver_name) {
8524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8525                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8526                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8528                 }
8529                 if (r->architecture) {
8530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8531                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8532                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8533                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8534                 }
8535                 if (r->driver_path) {
8536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8537                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8538                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8540                 }
8541                 if (r->data_file) {
8542                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8543                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8544                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8546                 }
8547                 if (r->config_file) {
8548                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8549                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8550                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8551                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8552                 }
8553                 if (r->help_file) {
8554                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8555                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8556                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8557                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8558                 }
8559                 if (r->monitor_name) {
8560                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8561                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8563                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8564                 }
8565                 if (r->default_datatype) {
8566                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8567                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8569                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8570                 }
8571                 if (r->dependent_files) {
8572                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8573                 }
8574                 if (r->previous_names) {
8575                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8576                 }
8577         }
8578         return NDR_ERR_SUCCESS;
8579 }
8580
8581 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8582 {
8583         uint32_t _ptr_driver_name;
8584         TALLOC_CTX *_mem_save_driver_name_0;
8585         uint32_t _ptr_architecture;
8586         TALLOC_CTX *_mem_save_architecture_0;
8587         uint32_t _ptr_driver_path;
8588         TALLOC_CTX *_mem_save_driver_path_0;
8589         uint32_t _ptr_data_file;
8590         TALLOC_CTX *_mem_save_data_file_0;
8591         uint32_t _ptr_config_file;
8592         TALLOC_CTX *_mem_save_config_file_0;
8593         uint32_t _ptr_help_file;
8594         TALLOC_CTX *_mem_save_help_file_0;
8595         uint32_t _ptr_monitor_name;
8596         TALLOC_CTX *_mem_save_monitor_name_0;
8597         uint32_t _ptr_default_datatype;
8598         TALLOC_CTX *_mem_save_default_datatype_0;
8599         uint32_t _ptr_dependent_files;
8600         TALLOC_CTX *_mem_save_dependent_files_0;
8601         uint32_t _ptr_previous_names;
8602         TALLOC_CTX *_mem_save_previous_names_0;
8603         if (ndr_flags & NDR_SCALARS) {
8604                 NDR_CHECK(ndr_pull_align(ndr, 5));
8605                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8607                 if (_ptr_driver_name) {
8608                         NDR_PULL_ALLOC(ndr, r->driver_name);
8609                 } else {
8610                         r->driver_name = NULL;
8611                 }
8612                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8613                 if (_ptr_architecture) {
8614                         NDR_PULL_ALLOC(ndr, r->architecture);
8615                 } else {
8616                         r->architecture = NULL;
8617                 }
8618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8619                 if (_ptr_driver_path) {
8620                         NDR_PULL_ALLOC(ndr, r->driver_path);
8621                 } else {
8622                         r->driver_path = NULL;
8623                 }
8624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8625                 if (_ptr_data_file) {
8626                         NDR_PULL_ALLOC(ndr, r->data_file);
8627                 } else {
8628                         r->data_file = NULL;
8629                 }
8630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8631                 if (_ptr_config_file) {
8632                         NDR_PULL_ALLOC(ndr, r->config_file);
8633                 } else {
8634                         r->config_file = NULL;
8635                 }
8636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8637                 if (_ptr_help_file) {
8638                         NDR_PULL_ALLOC(ndr, r->help_file);
8639                 } else {
8640                         r->help_file = NULL;
8641                 }
8642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8643                 if (_ptr_monitor_name) {
8644                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8645                 } else {
8646                         r->monitor_name = NULL;
8647                 }
8648                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8649                 if (_ptr_default_datatype) {
8650                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8651                 } else {
8652                         r->default_datatype = NULL;
8653                 }
8654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8656                 if (_ptr_dependent_files) {
8657                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8658                 } else {
8659                         r->dependent_files = NULL;
8660                 }
8661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8662                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8663                 if (_ptr_previous_names) {
8664                         NDR_PULL_ALLOC(ndr, r->previous_names);
8665                 } else {
8666                         r->previous_names = NULL;
8667                 }
8668         }
8669         if (ndr_flags & NDR_BUFFERS) {
8670                 if (r->driver_name) {
8671                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8672                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8673                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8674                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8675                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8676                                 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));
8677                         }
8678                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8679                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8680                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8681                 }
8682                 if (r->architecture) {
8683                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8684                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8685                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8686                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8687                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8688                                 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));
8689                         }
8690                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8691                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8693                 }
8694                 if (r->driver_path) {
8695                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8696                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8697                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8698                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8699                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8700                                 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));
8701                         }
8702                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8703                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8704                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8705                 }
8706                 if (r->data_file) {
8707                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8708                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8709                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8710                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8711                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8712                                 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));
8713                         }
8714                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8715                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8717                 }
8718                 if (r->config_file) {
8719                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8720                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8721                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8722                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8723                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8724                                 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));
8725                         }
8726                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8727                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8729                 }
8730                 if (r->help_file) {
8731                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8732                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8733                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8734                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8735                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8736                                 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));
8737                         }
8738                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8739                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8740                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8741                 }
8742                 if (r->monitor_name) {
8743                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8744                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8745                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8746                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8747                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8748                                 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));
8749                         }
8750                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8751                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8753                 }
8754                 if (r->default_datatype) {
8755                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8756                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8757                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8758                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8759                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8760                                 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));
8761                         }
8762                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8763                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8764                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8765                 }
8766                 if (r->dependent_files) {
8767                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8768                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8769                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8770                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8771                 }
8772                 if (r->previous_names) {
8773                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8774                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8775                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8776                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8777                 }
8778         }
8779         return NDR_ERR_SUCCESS;
8780 }
8781
8782 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8783 {
8784         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8785         ndr->depth++;
8786         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8787         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8788         ndr->depth++;
8789         if (r->driver_name) {
8790                 ndr_print_string(ndr, "driver_name", r->driver_name);
8791         }
8792         ndr->depth--;
8793         ndr_print_ptr(ndr, "architecture", r->architecture);
8794         ndr->depth++;
8795         if (r->architecture) {
8796                 ndr_print_string(ndr, "architecture", r->architecture);
8797         }
8798         ndr->depth--;
8799         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8800         ndr->depth++;
8801         if (r->driver_path) {
8802                 ndr_print_string(ndr, "driver_path", r->driver_path);
8803         }
8804         ndr->depth--;
8805         ndr_print_ptr(ndr, "data_file", r->data_file);
8806         ndr->depth++;
8807         if (r->data_file) {
8808                 ndr_print_string(ndr, "data_file", r->data_file);
8809         }
8810         ndr->depth--;
8811         ndr_print_ptr(ndr, "config_file", r->config_file);
8812         ndr->depth++;
8813         if (r->config_file) {
8814                 ndr_print_string(ndr, "config_file", r->config_file);
8815         }
8816         ndr->depth--;
8817         ndr_print_ptr(ndr, "help_file", r->help_file);
8818         ndr->depth++;
8819         if (r->help_file) {
8820                 ndr_print_string(ndr, "help_file", r->help_file);
8821         }
8822         ndr->depth--;
8823         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8824         ndr->depth++;
8825         if (r->monitor_name) {
8826                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8827         }
8828         ndr->depth--;
8829         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8830         ndr->depth++;
8831         if (r->default_datatype) {
8832                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8833         }
8834         ndr->depth--;
8835         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);
8836         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8837         ndr->depth++;
8838         if (r->dependent_files) {
8839                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8840         }
8841         ndr->depth--;
8842         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);
8843         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8844         ndr->depth++;
8845         if (r->previous_names) {
8846                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8847         }
8848         ndr->depth--;
8849         ndr->depth--;
8850 }
8851
8852 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8853 {
8854         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8855         return NDR_ERR_SUCCESS;
8856 }
8857
8858 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8859 {
8860         uint32_t v;
8861         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8862         *r = v;
8863         return NDR_ERR_SUCCESS;
8864 }
8865
8866 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
8867 {
8868         ndr_print_uint32(ndr, name, r);
8869         ndr->depth++;
8870         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
8871         ndr->depth--;
8872 }
8873
8874 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8875 {
8876         if (ndr_flags & NDR_SCALARS) {
8877                 NDR_CHECK(ndr_push_align(ndr, 8));
8878                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8879                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8880                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8881                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8882                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8884                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8886                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8890                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8891                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8892                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8897         }
8898         if (ndr_flags & NDR_BUFFERS) {
8899                 if (r->driver_name) {
8900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8901                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8903                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8904                 }
8905                 if (r->architecture) {
8906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8907                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8908                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8910                 }
8911                 if (r->driver_path) {
8912                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8913                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8915                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8916                 }
8917                 if (r->data_file) {
8918                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8919                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8920                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8921                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8922                 }
8923                 if (r->config_file) {
8924                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8925                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8927                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8928                 }
8929                 if (r->help_file) {
8930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8931                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8933                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8934                 }
8935                 if (r->monitor_name) {
8936                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8937                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8939                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8940                 }
8941                 if (r->default_datatype) {
8942                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8943                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8944                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8945                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8946                 }
8947                 if (r->dependent_files) {
8948                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8949                 }
8950                 if (r->previous_names) {
8951                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8952                 }
8953                 if (r->manufacturer_name) {
8954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8957                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8958                 }
8959                 if (r->manufacturer_url) {
8960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8961                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8962                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8964                 }
8965                 if (r->hardware_id) {
8966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8968                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8969                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8970                 }
8971                 if (r->provider) {
8972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8976                 }
8977         }
8978         return NDR_ERR_SUCCESS;
8979 }
8980
8981 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8982 {
8983         uint32_t _ptr_driver_name;
8984         TALLOC_CTX *_mem_save_driver_name_0;
8985         uint32_t _ptr_architecture;
8986         TALLOC_CTX *_mem_save_architecture_0;
8987         uint32_t _ptr_driver_path;
8988         TALLOC_CTX *_mem_save_driver_path_0;
8989         uint32_t _ptr_data_file;
8990         TALLOC_CTX *_mem_save_data_file_0;
8991         uint32_t _ptr_config_file;
8992         TALLOC_CTX *_mem_save_config_file_0;
8993         uint32_t _ptr_help_file;
8994         TALLOC_CTX *_mem_save_help_file_0;
8995         uint32_t _ptr_monitor_name;
8996         TALLOC_CTX *_mem_save_monitor_name_0;
8997         uint32_t _ptr_default_datatype;
8998         TALLOC_CTX *_mem_save_default_datatype_0;
8999         uint32_t _ptr_dependent_files;
9000         TALLOC_CTX *_mem_save_dependent_files_0;
9001         uint32_t _ptr_previous_names;
9002         TALLOC_CTX *_mem_save_previous_names_0;
9003         uint32_t _ptr_manufacturer_name;
9004         TALLOC_CTX *_mem_save_manufacturer_name_0;
9005         uint32_t _ptr_manufacturer_url;
9006         TALLOC_CTX *_mem_save_manufacturer_url_0;
9007         uint32_t _ptr_hardware_id;
9008         TALLOC_CTX *_mem_save_hardware_id_0;
9009         uint32_t _ptr_provider;
9010         TALLOC_CTX *_mem_save_provider_0;
9011         if (ndr_flags & NDR_SCALARS) {
9012                 NDR_CHECK(ndr_pull_align(ndr, 8));
9013                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9015                 if (_ptr_driver_name) {
9016                         NDR_PULL_ALLOC(ndr, r->driver_name);
9017                 } else {
9018                         r->driver_name = NULL;
9019                 }
9020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9021                 if (_ptr_architecture) {
9022                         NDR_PULL_ALLOC(ndr, r->architecture);
9023                 } else {
9024                         r->architecture = NULL;
9025                 }
9026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9027                 if (_ptr_driver_path) {
9028                         NDR_PULL_ALLOC(ndr, r->driver_path);
9029                 } else {
9030                         r->driver_path = NULL;
9031                 }
9032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9033                 if (_ptr_data_file) {
9034                         NDR_PULL_ALLOC(ndr, r->data_file);
9035                 } else {
9036                         r->data_file = NULL;
9037                 }
9038                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9039                 if (_ptr_config_file) {
9040                         NDR_PULL_ALLOC(ndr, r->config_file);
9041                 } else {
9042                         r->config_file = NULL;
9043                 }
9044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9045                 if (_ptr_help_file) {
9046                         NDR_PULL_ALLOC(ndr, r->help_file);
9047                 } else {
9048                         r->help_file = NULL;
9049                 }
9050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9051                 if (_ptr_monitor_name) {
9052                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9053                 } else {
9054                         r->monitor_name = NULL;
9055                 }
9056                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9057                 if (_ptr_default_datatype) {
9058                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9059                 } else {
9060                         r->default_datatype = NULL;
9061                 }
9062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9064                 if (_ptr_dependent_files) {
9065                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9066                 } else {
9067                         r->dependent_files = NULL;
9068                 }
9069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9071                 if (_ptr_previous_names) {
9072                         NDR_PULL_ALLOC(ndr, r->previous_names);
9073                 } else {
9074                         r->previous_names = NULL;
9075                 }
9076                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9077                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9079                 if (_ptr_manufacturer_name) {
9080                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9081                 } else {
9082                         r->manufacturer_name = NULL;
9083                 }
9084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9085                 if (_ptr_manufacturer_url) {
9086                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9087                 } else {
9088                         r->manufacturer_url = NULL;
9089                 }
9090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9091                 if (_ptr_hardware_id) {
9092                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9093                 } else {
9094                         r->hardware_id = NULL;
9095                 }
9096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9097                 if (_ptr_provider) {
9098                         NDR_PULL_ALLOC(ndr, r->provider);
9099                 } else {
9100                         r->provider = NULL;
9101                 }
9102         }
9103         if (ndr_flags & NDR_BUFFERS) {
9104                 if (r->driver_name) {
9105                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9106                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9109                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9110                                 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));
9111                         }
9112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9115                 }
9116                 if (r->architecture) {
9117                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9118                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9121                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9122                                 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));
9123                         }
9124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9127                 }
9128                 if (r->driver_path) {
9129                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9130                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9133                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9134                                 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));
9135                         }
9136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9139                 }
9140                 if (r->data_file) {
9141                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9142                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9145                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9146                                 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));
9147                         }
9148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9151                 }
9152                 if (r->config_file) {
9153                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9154                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9155                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9156                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9157                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9158                                 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));
9159                         }
9160                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9161                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9163                 }
9164                 if (r->help_file) {
9165                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9166                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9167                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9168                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9169                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9170                                 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));
9171                         }
9172                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9173                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9174                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9175                 }
9176                 if (r->monitor_name) {
9177                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9178                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9180                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9181                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9182                                 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));
9183                         }
9184                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9185                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9187                 }
9188                 if (r->default_datatype) {
9189                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9190                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9191                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9192                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9193                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9194                                 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));
9195                         }
9196                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9197                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9198                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9199                 }
9200                 if (r->dependent_files) {
9201                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9202                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9203                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9205                 }
9206                 if (r->previous_names) {
9207                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9208                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9209                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9211                 }
9212                 if (r->manufacturer_name) {
9213                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9214                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9215                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9216                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9217                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9218                                 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));
9219                         }
9220                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9221                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9222                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9223                 }
9224                 if (r->manufacturer_url) {
9225                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9226                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9228                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9229                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9230                                 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));
9231                         }
9232                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9233                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9235                 }
9236                 if (r->hardware_id) {
9237                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9238                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9239                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9240                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9241                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9242                                 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));
9243                         }
9244                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9245                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9247                 }
9248                 if (r->provider) {
9249                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9250                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9251                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9252                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9253                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9254                                 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));
9255                         }
9256                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9257                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9259                 }
9260         }
9261         return NDR_ERR_SUCCESS;
9262 }
9263
9264 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9265 {
9266         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9267         ndr->depth++;
9268         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9269         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9270         ndr->depth++;
9271         if (r->driver_name) {
9272                 ndr_print_string(ndr, "driver_name", r->driver_name);
9273         }
9274         ndr->depth--;
9275         ndr_print_ptr(ndr, "architecture", r->architecture);
9276         ndr->depth++;
9277         if (r->architecture) {
9278                 ndr_print_string(ndr, "architecture", r->architecture);
9279         }
9280         ndr->depth--;
9281         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9282         ndr->depth++;
9283         if (r->driver_path) {
9284                 ndr_print_string(ndr, "driver_path", r->driver_path);
9285         }
9286         ndr->depth--;
9287         ndr_print_ptr(ndr, "data_file", r->data_file);
9288         ndr->depth++;
9289         if (r->data_file) {
9290                 ndr_print_string(ndr, "data_file", r->data_file);
9291         }
9292         ndr->depth--;
9293         ndr_print_ptr(ndr, "config_file", r->config_file);
9294         ndr->depth++;
9295         if (r->config_file) {
9296                 ndr_print_string(ndr, "config_file", r->config_file);
9297         }
9298         ndr->depth--;
9299         ndr_print_ptr(ndr, "help_file", r->help_file);
9300         ndr->depth++;
9301         if (r->help_file) {
9302                 ndr_print_string(ndr, "help_file", r->help_file);
9303         }
9304         ndr->depth--;
9305         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9306         ndr->depth++;
9307         if (r->monitor_name) {
9308                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9309         }
9310         ndr->depth--;
9311         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9312         ndr->depth++;
9313         if (r->default_datatype) {
9314                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9315         }
9316         ndr->depth--;
9317         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);
9318         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9319         ndr->depth++;
9320         if (r->dependent_files) {
9321                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9322         }
9323         ndr->depth--;
9324         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);
9325         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9326         ndr->depth++;
9327         if (r->previous_names) {
9328                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9329         }
9330         ndr->depth--;
9331         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9332         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9333         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9334         ndr->depth++;
9335         if (r->manufacturer_name) {
9336                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9337         }
9338         ndr->depth--;
9339         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9340         ndr->depth++;
9341         if (r->manufacturer_url) {
9342                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9343         }
9344         ndr->depth--;
9345         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9346         ndr->depth++;
9347         if (r->hardware_id) {
9348                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9349         }
9350         ndr->depth--;
9351         ndr_print_ptr(ndr, "provider", r->provider);
9352         ndr->depth++;
9353         if (r->provider) {
9354                 ndr_print_string(ndr, "provider", r->provider);
9355         }
9356         ndr->depth--;
9357         ndr->depth--;
9358 }
9359
9360 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9361 {
9362         if (ndr_flags & NDR_SCALARS) {
9363                 NDR_CHECK(ndr_push_align(ndr, 8));
9364                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9369                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9377                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9378                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9381                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9391                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9392                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9393         }
9394         if (ndr_flags & NDR_BUFFERS) {
9395                 if (r->driver_name) {
9396                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9399                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9400                 }
9401                 if (r->architecture) {
9402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9405                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9406                 }
9407                 if (r->driver_path) {
9408                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9411                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9412                 }
9413                 if (r->data_file) {
9414                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9415                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9417                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9418                 }
9419                 if (r->config_file) {
9420                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9421                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9423                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9424                 }
9425                 if (r->help_file) {
9426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9429                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9430                 }
9431                 if (r->monitor_name) {
9432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9435                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9436                 }
9437                 if (r->default_datatype) {
9438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9441                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9442                 }
9443                 if (r->dependent_files) {
9444                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9445                 }
9446                 if (r->previous_names) {
9447                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9448                 }
9449                 if (r->manufacturer_name) {
9450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9453                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9454                 }
9455                 if (r->manufacturer_url) {
9456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9459                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9460                 }
9461                 if (r->hardware_id) {
9462                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9463                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9464                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9465                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9466                 }
9467                 if (r->provider) {
9468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9471                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9472                 }
9473                 if (r->print_processor) {
9474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9478                 }
9479                 if (r->vendor_setup) {
9480                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9481                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9482                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9483                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9484                 }
9485                 if (r->color_profiles) {
9486                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9487                 }
9488                 if (r->inf_path) {
9489                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9490                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9491                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9492                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9493                 }
9494                 if (r->core_driver_dependencies) {
9495                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9496                 }
9497         }
9498         return NDR_ERR_SUCCESS;
9499 }
9500
9501 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9502 {
9503         uint32_t _ptr_driver_name;
9504         TALLOC_CTX *_mem_save_driver_name_0;
9505         uint32_t _ptr_architecture;
9506         TALLOC_CTX *_mem_save_architecture_0;
9507         uint32_t _ptr_driver_path;
9508         TALLOC_CTX *_mem_save_driver_path_0;
9509         uint32_t _ptr_data_file;
9510         TALLOC_CTX *_mem_save_data_file_0;
9511         uint32_t _ptr_config_file;
9512         TALLOC_CTX *_mem_save_config_file_0;
9513         uint32_t _ptr_help_file;
9514         TALLOC_CTX *_mem_save_help_file_0;
9515         uint32_t _ptr_monitor_name;
9516         TALLOC_CTX *_mem_save_monitor_name_0;
9517         uint32_t _ptr_default_datatype;
9518         TALLOC_CTX *_mem_save_default_datatype_0;
9519         uint32_t _ptr_dependent_files;
9520         TALLOC_CTX *_mem_save_dependent_files_0;
9521         uint32_t _ptr_previous_names;
9522         TALLOC_CTX *_mem_save_previous_names_0;
9523         uint32_t _ptr_manufacturer_name;
9524         TALLOC_CTX *_mem_save_manufacturer_name_0;
9525         uint32_t _ptr_manufacturer_url;
9526         TALLOC_CTX *_mem_save_manufacturer_url_0;
9527         uint32_t _ptr_hardware_id;
9528         TALLOC_CTX *_mem_save_hardware_id_0;
9529         uint32_t _ptr_provider;
9530         TALLOC_CTX *_mem_save_provider_0;
9531         uint32_t _ptr_print_processor;
9532         TALLOC_CTX *_mem_save_print_processor_0;
9533         uint32_t _ptr_vendor_setup;
9534         TALLOC_CTX *_mem_save_vendor_setup_0;
9535         uint32_t _ptr_color_profiles;
9536         TALLOC_CTX *_mem_save_color_profiles_0;
9537         uint32_t _ptr_inf_path;
9538         TALLOC_CTX *_mem_save_inf_path_0;
9539         uint32_t _ptr_core_driver_dependencies;
9540         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9541         if (ndr_flags & NDR_SCALARS) {
9542                 NDR_CHECK(ndr_pull_align(ndr, 8));
9543                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9544                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9545                 if (_ptr_driver_name) {
9546                         NDR_PULL_ALLOC(ndr, r->driver_name);
9547                 } else {
9548                         r->driver_name = NULL;
9549                 }
9550                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9551                 if (_ptr_architecture) {
9552                         NDR_PULL_ALLOC(ndr, r->architecture);
9553                 } else {
9554                         r->architecture = NULL;
9555                 }
9556                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9557                 if (_ptr_driver_path) {
9558                         NDR_PULL_ALLOC(ndr, r->driver_path);
9559                 } else {
9560                         r->driver_path = NULL;
9561                 }
9562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9563                 if (_ptr_data_file) {
9564                         NDR_PULL_ALLOC(ndr, r->data_file);
9565                 } else {
9566                         r->data_file = NULL;
9567                 }
9568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9569                 if (_ptr_config_file) {
9570                         NDR_PULL_ALLOC(ndr, r->config_file);
9571                 } else {
9572                         r->config_file = NULL;
9573                 }
9574                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9575                 if (_ptr_help_file) {
9576                         NDR_PULL_ALLOC(ndr, r->help_file);
9577                 } else {
9578                         r->help_file = NULL;
9579                 }
9580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9581                 if (_ptr_monitor_name) {
9582                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9583                 } else {
9584                         r->monitor_name = NULL;
9585                 }
9586                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9587                 if (_ptr_default_datatype) {
9588                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9589                 } else {
9590                         r->default_datatype = NULL;
9591                 }
9592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9594                 if (_ptr_dependent_files) {
9595                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9596                 } else {
9597                         r->dependent_files = NULL;
9598                 }
9599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9600                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9601                 if (_ptr_previous_names) {
9602                         NDR_PULL_ALLOC(ndr, r->previous_names);
9603                 } else {
9604                         r->previous_names = NULL;
9605                 }
9606                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9607                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9608                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9609                 if (_ptr_manufacturer_name) {
9610                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9611                 } else {
9612                         r->manufacturer_name = NULL;
9613                 }
9614                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9615                 if (_ptr_manufacturer_url) {
9616                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9617                 } else {
9618                         r->manufacturer_url = NULL;
9619                 }
9620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9621                 if (_ptr_hardware_id) {
9622                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9623                 } else {
9624                         r->hardware_id = NULL;
9625                 }
9626                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9627                 if (_ptr_provider) {
9628                         NDR_PULL_ALLOC(ndr, r->provider);
9629                 } else {
9630                         r->provider = NULL;
9631                 }
9632                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9633                 if (_ptr_print_processor) {
9634                         NDR_PULL_ALLOC(ndr, r->print_processor);
9635                 } else {
9636                         r->print_processor = NULL;
9637                 }
9638                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9639                 if (_ptr_vendor_setup) {
9640                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9641                 } else {
9642                         r->vendor_setup = NULL;
9643                 }
9644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9645                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9646                 if (_ptr_color_profiles) {
9647                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9648                 } else {
9649                         r->color_profiles = NULL;
9650                 }
9651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9652                 if (_ptr_inf_path) {
9653                         NDR_PULL_ALLOC(ndr, r->inf_path);
9654                 } else {
9655                         r->inf_path = NULL;
9656                 }
9657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9659                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9660                 if (_ptr_core_driver_dependencies) {
9661                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9662                 } else {
9663                         r->core_driver_dependencies = NULL;
9664                 }
9665                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9666                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9667         }
9668         if (ndr_flags & NDR_BUFFERS) {
9669                 if (r->driver_name) {
9670                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9671                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9672                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9673                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9674                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9675                                 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));
9676                         }
9677                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9678                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9679                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9680                 }
9681                 if (r->architecture) {
9682                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9683                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9684                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9685                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9686                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9687                                 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));
9688                         }
9689                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9690                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9692                 }
9693                 if (r->driver_path) {
9694                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9695                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9698                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9699                                 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));
9700                         }
9701                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9702                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9704                 }
9705                 if (r->data_file) {
9706                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9707                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9708                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9709                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9710                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9711                                 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));
9712                         }
9713                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9714                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9716                 }
9717                 if (r->config_file) {
9718                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9719                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9720                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9721                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9722                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9723                                 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));
9724                         }
9725                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9726                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9728                 }
9729                 if (r->help_file) {
9730                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9731                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9732                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9733                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9734                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9735                                 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));
9736                         }
9737                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9738                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9740                 }
9741                 if (r->monitor_name) {
9742                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9743                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9744                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9745                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9746                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9747                                 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));
9748                         }
9749                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9750                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9751                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9752                 }
9753                 if (r->default_datatype) {
9754                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9755                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9756                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9757                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9758                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9759                                 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));
9760                         }
9761                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9762                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9764                 }
9765                 if (r->dependent_files) {
9766                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9767                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9768                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9770                 }
9771                 if (r->previous_names) {
9772                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9773                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9774                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9776                 }
9777                 if (r->manufacturer_name) {
9778                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9779                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9780                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9781                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9782                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9783                                 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));
9784                         }
9785                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9786                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9788                 }
9789                 if (r->manufacturer_url) {
9790                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9791                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9794                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9795                                 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));
9796                         }
9797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9800                 }
9801                 if (r->hardware_id) {
9802                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9803                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9804                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9805                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9806                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9807                                 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));
9808                         }
9809                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9810                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9812                 }
9813                 if (r->provider) {
9814                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9815                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9816                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9817                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9818                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9819                                 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));
9820                         }
9821                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9822                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9824                 }
9825                 if (r->print_processor) {
9826                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9827                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9830                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9831                                 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));
9832                         }
9833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9836                 }
9837                 if (r->vendor_setup) {
9838                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9839                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9842                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9843                                 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));
9844                         }
9845                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9848                 }
9849                 if (r->color_profiles) {
9850                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9851                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9852                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9853                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9854                 }
9855                 if (r->inf_path) {
9856                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9857                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9858                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9859                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9860                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9861                                 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));
9862                         }
9863                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9864                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9865                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9866                 }
9867                 if (r->core_driver_dependencies) {
9868                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9869                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9870                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9872                 }
9873         }
9874         return NDR_ERR_SUCCESS;
9875 }
9876
9877 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9878 {
9879         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9880         ndr->depth++;
9881         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9882         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9883         ndr->depth++;
9884         if (r->driver_name) {
9885                 ndr_print_string(ndr, "driver_name", r->driver_name);
9886         }
9887         ndr->depth--;
9888         ndr_print_ptr(ndr, "architecture", r->architecture);
9889         ndr->depth++;
9890         if (r->architecture) {
9891                 ndr_print_string(ndr, "architecture", r->architecture);
9892         }
9893         ndr->depth--;
9894         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9895         ndr->depth++;
9896         if (r->driver_path) {
9897                 ndr_print_string(ndr, "driver_path", r->driver_path);
9898         }
9899         ndr->depth--;
9900         ndr_print_ptr(ndr, "data_file", r->data_file);
9901         ndr->depth++;
9902         if (r->data_file) {
9903                 ndr_print_string(ndr, "data_file", r->data_file);
9904         }
9905         ndr->depth--;
9906         ndr_print_ptr(ndr, "config_file", r->config_file);
9907         ndr->depth++;
9908         if (r->config_file) {
9909                 ndr_print_string(ndr, "config_file", r->config_file);
9910         }
9911         ndr->depth--;
9912         ndr_print_ptr(ndr, "help_file", r->help_file);
9913         ndr->depth++;
9914         if (r->help_file) {
9915                 ndr_print_string(ndr, "help_file", r->help_file);
9916         }
9917         ndr->depth--;
9918         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9919         ndr->depth++;
9920         if (r->monitor_name) {
9921                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9922         }
9923         ndr->depth--;
9924         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9925         ndr->depth++;
9926         if (r->default_datatype) {
9927                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9928         }
9929         ndr->depth--;
9930         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);
9931         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9932         ndr->depth++;
9933         if (r->dependent_files) {
9934                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9935         }
9936         ndr->depth--;
9937         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);
9938         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9939         ndr->depth++;
9940         if (r->previous_names) {
9941                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9942         }
9943         ndr->depth--;
9944         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9945         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9946         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9947         ndr->depth++;
9948         if (r->manufacturer_name) {
9949                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9950         }
9951         ndr->depth--;
9952         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9953         ndr->depth++;
9954         if (r->manufacturer_url) {
9955                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9956         }
9957         ndr->depth--;
9958         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9959         ndr->depth++;
9960         if (r->hardware_id) {
9961                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9962         }
9963         ndr->depth--;
9964         ndr_print_ptr(ndr, "provider", r->provider);
9965         ndr->depth++;
9966         if (r->provider) {
9967                 ndr_print_string(ndr, "provider", r->provider);
9968         }
9969         ndr->depth--;
9970         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9971         ndr->depth++;
9972         if (r->print_processor) {
9973                 ndr_print_string(ndr, "print_processor", r->print_processor);
9974         }
9975         ndr->depth--;
9976         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9977         ndr->depth++;
9978         if (r->vendor_setup) {
9979                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9980         }
9981         ndr->depth--;
9982         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);
9983         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9984         ndr->depth++;
9985         if (r->color_profiles) {
9986                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9987         }
9988         ndr->depth--;
9989         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9990         ndr->depth++;
9991         if (r->inf_path) {
9992                 ndr_print_string(ndr, "inf_path", r->inf_path);
9993         }
9994         ndr->depth--;
9995         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9996         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);
9997         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9998         ndr->depth++;
9999         if (r->core_driver_dependencies) {
10000                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10001         }
10002         ndr->depth--;
10003         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10004         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10005         ndr->depth--;
10006 }
10007
10008 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10009 {
10010         if (ndr_flags & NDR_SCALARS) {
10011                 int level = ndr_push_get_switch_value(ndr, r);
10012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10013                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10014                 switch (level) {
10015                         case 1: {
10016                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10017                         break; }
10018
10019                         case 2: {
10020                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10021                         break; }
10022
10023                         case 3: {
10024                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10025                         break; }
10026
10027                         case 4: {
10028                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10029                         break; }
10030
10031                         case 6: {
10032                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10033                         break; }
10034
10035                         case 8: {
10036                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10037                         break; }
10038
10039                         default:
10040                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10041                 }
10042         }
10043         if (ndr_flags & NDR_BUFFERS) {
10044                 int level = ndr_push_get_switch_value(ndr, r);
10045                 switch (level) {
10046                         case 1:
10047                                 if (r->info1) {
10048                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10049                                 }
10050                         break;
10051
10052                         case 2:
10053                                 if (r->info2) {
10054                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10055                                 }
10056                         break;
10057
10058                         case 3:
10059                                 if (r->info3) {
10060                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10061                                 }
10062                         break;
10063
10064                         case 4:
10065                                 if (r->info4) {
10066                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10067                                 }
10068                         break;
10069
10070                         case 6:
10071                                 if (r->info6) {
10072                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10073                                 }
10074                         break;
10075
10076                         case 8:
10077                                 if (r->info8) {
10078                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10079                                 }
10080                         break;
10081
10082                         default:
10083                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10084                 }
10085         }
10086         return NDR_ERR_SUCCESS;
10087 }
10088
10089 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10090 {
10091         int level;
10092         uint32_t _level;
10093         TALLOC_CTX *_mem_save_info1_0;
10094         TALLOC_CTX *_mem_save_info2_0;
10095         TALLOC_CTX *_mem_save_info3_0;
10096         TALLOC_CTX *_mem_save_info4_0;
10097         TALLOC_CTX *_mem_save_info6_0;
10098         TALLOC_CTX *_mem_save_info8_0;
10099         level = ndr_pull_get_switch_value(ndr, r);
10100         if (ndr_flags & NDR_SCALARS) {
10101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10102                 if (_level != level) {
10103                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10104                 }
10105                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10106                 switch (level) {
10107                         case 1: {
10108                                 uint32_t _ptr_info1;
10109                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10110                                 if (_ptr_info1) {
10111                                         NDR_PULL_ALLOC(ndr, r->info1);
10112                                 } else {
10113                                         r->info1 = NULL;
10114                                 }
10115                         break; }
10116
10117                         case 2: {
10118                                 uint32_t _ptr_info2;
10119                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10120                                 if (_ptr_info2) {
10121                                         NDR_PULL_ALLOC(ndr, r->info2);
10122                                 } else {
10123                                         r->info2 = NULL;
10124                                 }
10125                         break; }
10126
10127                         case 3: {
10128                                 uint32_t _ptr_info3;
10129                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10130                                 if (_ptr_info3) {
10131                                         NDR_PULL_ALLOC(ndr, r->info3);
10132                                 } else {
10133                                         r->info3 = NULL;
10134                                 }
10135                         break; }
10136
10137                         case 4: {
10138                                 uint32_t _ptr_info4;
10139                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10140                                 if (_ptr_info4) {
10141                                         NDR_PULL_ALLOC(ndr, r->info4);
10142                                 } else {
10143                                         r->info4 = NULL;
10144                                 }
10145                         break; }
10146
10147                         case 6: {
10148                                 uint32_t _ptr_info6;
10149                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10150                                 if (_ptr_info6) {
10151                                         NDR_PULL_ALLOC(ndr, r->info6);
10152                                 } else {
10153                                         r->info6 = NULL;
10154                                 }
10155                         break; }
10156
10157                         case 8: {
10158                                 uint32_t _ptr_info8;
10159                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10160                                 if (_ptr_info8) {
10161                                         NDR_PULL_ALLOC(ndr, r->info8);
10162                                 } else {
10163                                         r->info8 = NULL;
10164                                 }
10165                         break; }
10166
10167                         default:
10168                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10169                 }
10170         }
10171         if (ndr_flags & NDR_BUFFERS) {
10172                 switch (level) {
10173                         case 1:
10174                                 if (r->info1) {
10175                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10176                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10177                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10178                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10179                                 }
10180                         break;
10181
10182                         case 2:
10183                                 if (r->info2) {
10184                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10185                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10186                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10187                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10188                                 }
10189                         break;
10190
10191                         case 3:
10192                                 if (r->info3) {
10193                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10194                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10195                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10196                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10197                                 }
10198                         break;
10199
10200                         case 4:
10201                                 if (r->info4) {
10202                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10203                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10204                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10205                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10206                                 }
10207                         break;
10208
10209                         case 6:
10210                                 if (r->info6) {
10211                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10212                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10213                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10214                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10215                                 }
10216                         break;
10217
10218                         case 8:
10219                                 if (r->info8) {
10220                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10221                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10222                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10223                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10224                                 }
10225                         break;
10226
10227                         default:
10228                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10229                 }
10230         }
10231         return NDR_ERR_SUCCESS;
10232 }
10233
10234 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10235 {
10236         int level;
10237         level = ndr_print_get_switch_value(ndr, r);
10238         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10239         switch (level) {
10240                 case 1:
10241                         ndr_print_ptr(ndr, "info1", r->info1);
10242                         ndr->depth++;
10243                         if (r->info1) {
10244                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10245                         }
10246                         ndr->depth--;
10247                 break;
10248
10249                 case 2:
10250                         ndr_print_ptr(ndr, "info2", r->info2);
10251                         ndr->depth++;
10252                         if (r->info2) {
10253                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10254                         }
10255                         ndr->depth--;
10256                 break;
10257
10258                 case 3:
10259                         ndr_print_ptr(ndr, "info3", r->info3);
10260                         ndr->depth++;
10261                         if (r->info3) {
10262                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10263                         }
10264                         ndr->depth--;
10265                 break;
10266
10267                 case 4:
10268                         ndr_print_ptr(ndr, "info4", r->info4);
10269                         ndr->depth++;
10270                         if (r->info4) {
10271                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10272                         }
10273                         ndr->depth--;
10274                 break;
10275
10276                 case 6:
10277                         ndr_print_ptr(ndr, "info6", r->info6);
10278                         ndr->depth++;
10279                         if (r->info6) {
10280                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10281                         }
10282                         ndr->depth--;
10283                 break;
10284
10285                 case 8:
10286                         ndr_print_ptr(ndr, "info8", r->info8);
10287                         ndr->depth++;
10288                         if (r->info8) {
10289                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10290                         }
10291                         ndr->depth--;
10292                 break;
10293
10294                 default:
10295                         ndr_print_bad_level(ndr, name, level);
10296         }
10297 }
10298
10299 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10300 {
10301         if (ndr_flags & NDR_SCALARS) {
10302                 NDR_CHECK(ndr_push_align(ndr, 5));
10303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10304                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10305                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10306         }
10307         if (ndr_flags & NDR_BUFFERS) {
10308                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10309         }
10310         return NDR_ERR_SUCCESS;
10311 }
10312
10313 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10314 {
10315         if (ndr_flags & NDR_SCALARS) {
10316                 NDR_CHECK(ndr_pull_align(ndr, 5));
10317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10318                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10319                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10320         }
10321         if (ndr_flags & NDR_BUFFERS) {
10322                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10323         }
10324         return NDR_ERR_SUCCESS;
10325 }
10326
10327 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10328 {
10329         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10330         ndr->depth++;
10331         ndr_print_uint32(ndr, "level", r->level);
10332         ndr_print_set_switch_value(ndr, &r->info, r->level);
10333         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10334         ndr->depth--;
10335 }
10336
10337 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10338 {
10339         if (ndr_flags & NDR_SCALARS) {
10340                 NDR_CHECK(ndr_push_align(ndr, 5));
10341                 {
10342                         uint32_t _flags_save_string = ndr->flags;
10343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10344                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10345                         ndr->flags = _flags_save_string;
10346                 }
10347         }
10348         if (ndr_flags & NDR_BUFFERS) {
10349                 {
10350                         uint32_t _flags_save_string = ndr->flags;
10351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10352                         if (r->driver_name) {
10353                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10354                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10355                         }
10356                         ndr->flags = _flags_save_string;
10357                 }
10358         }
10359         return NDR_ERR_SUCCESS;
10360 }
10361
10362 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10363 {
10364         uint32_t _ptr_driver_name;
10365         TALLOC_CTX *_mem_save_driver_name_0;
10366         if (ndr_flags & NDR_SCALARS) {
10367                 NDR_CHECK(ndr_pull_align(ndr, 5));
10368                 {
10369                         uint32_t _flags_save_string = ndr->flags;
10370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10371                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10372                         if (_ptr_driver_name) {
10373                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10374                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10375                         } else {
10376                                 r->driver_name = NULL;
10377                         }
10378                         ndr->flags = _flags_save_string;
10379                 }
10380         }
10381         if (ndr_flags & NDR_BUFFERS) {
10382                 {
10383                         uint32_t _flags_save_string = ndr->flags;
10384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10385                         if (r->driver_name) {
10386                                 uint32_t _relative_save_offset;
10387                                 _relative_save_offset = ndr->offset;
10388                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10389                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10390                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10391                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10393                                 ndr->offset = _relative_save_offset;
10394                         }
10395                         ndr->flags = _flags_save_string;
10396                 }
10397         }
10398         return NDR_ERR_SUCCESS;
10399 }
10400
10401 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10402 {
10403         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10404         ndr->depth++;
10405         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10406         ndr->depth++;
10407         if (r->driver_name) {
10408                 ndr_print_string(ndr, "driver_name", r->driver_name);
10409         }
10410         ndr->depth--;
10411         ndr->depth--;
10412 }
10413
10414 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10415 {
10416         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10417 }
10418
10419 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10420 {
10421         if (ndr_flags & NDR_SCALARS) {
10422                 NDR_CHECK(ndr_push_align(ndr, 5));
10423                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10424                 {
10425                         uint32_t _flags_save_string = ndr->flags;
10426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10427                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10428                         ndr->flags = _flags_save_string;
10429                 }
10430                 {
10431                         uint32_t _flags_save_string = ndr->flags;
10432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10433                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10434                         ndr->flags = _flags_save_string;
10435                 }
10436                 {
10437                         uint32_t _flags_save_string = ndr->flags;
10438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10440                         ndr->flags = _flags_save_string;
10441                 }
10442                 {
10443                         uint32_t _flags_save_string = ndr->flags;
10444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10445                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10452                         ndr->flags = _flags_save_string;
10453                 }
10454         }
10455         if (ndr_flags & NDR_BUFFERS) {
10456                 {
10457                         uint32_t _flags_save_string = ndr->flags;
10458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10459                         if (r->driver_name) {
10460                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10461                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10462                         }
10463                         ndr->flags = _flags_save_string;
10464                 }
10465                 {
10466                         uint32_t _flags_save_string = ndr->flags;
10467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10468                         if (r->architecture) {
10469                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10470                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10471                         }
10472                         ndr->flags = _flags_save_string;
10473                 }
10474                 {
10475                         uint32_t _flags_save_string = ndr->flags;
10476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10477                         if (r->driver_path) {
10478                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10479                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10480                         }
10481                         ndr->flags = _flags_save_string;
10482                 }
10483                 {
10484                         uint32_t _flags_save_string = ndr->flags;
10485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10486                         if (r->data_file) {
10487                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10488                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10489                         }
10490                         ndr->flags = _flags_save_string;
10491                 }
10492                 {
10493                         uint32_t _flags_save_string = ndr->flags;
10494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10495                         if (r->config_file) {
10496                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10497                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10498                         }
10499                         ndr->flags = _flags_save_string;
10500                 }
10501         }
10502         return NDR_ERR_SUCCESS;
10503 }
10504
10505 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10506 {
10507         uint32_t _ptr_driver_name;
10508         TALLOC_CTX *_mem_save_driver_name_0;
10509         uint32_t _ptr_architecture;
10510         TALLOC_CTX *_mem_save_architecture_0;
10511         uint32_t _ptr_driver_path;
10512         TALLOC_CTX *_mem_save_driver_path_0;
10513         uint32_t _ptr_data_file;
10514         TALLOC_CTX *_mem_save_data_file_0;
10515         uint32_t _ptr_config_file;
10516         TALLOC_CTX *_mem_save_config_file_0;
10517         if (ndr_flags & NDR_SCALARS) {
10518                 NDR_CHECK(ndr_pull_align(ndr, 5));
10519                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10520                 {
10521                         uint32_t _flags_save_string = ndr->flags;
10522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10523                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10524                         if (_ptr_driver_name) {
10525                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10526                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10527                         } else {
10528                                 r->driver_name = NULL;
10529                         }
10530                         ndr->flags = _flags_save_string;
10531                 }
10532                 {
10533                         uint32_t _flags_save_string = ndr->flags;
10534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10535                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10536                         if (_ptr_architecture) {
10537                                 NDR_PULL_ALLOC(ndr, r->architecture);
10538                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10539                         } else {
10540                                 r->architecture = NULL;
10541                         }
10542                         ndr->flags = _flags_save_string;
10543                 }
10544                 {
10545                         uint32_t _flags_save_string = ndr->flags;
10546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10547                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10548                         if (_ptr_driver_path) {
10549                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10550                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10551                         } else {
10552                                 r->driver_path = NULL;
10553                         }
10554                         ndr->flags = _flags_save_string;
10555                 }
10556                 {
10557                         uint32_t _flags_save_string = ndr->flags;
10558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10560                         if (_ptr_data_file) {
10561                                 NDR_PULL_ALLOC(ndr, r->data_file);
10562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10563                         } else {
10564                                 r->data_file = NULL;
10565                         }
10566                         ndr->flags = _flags_save_string;
10567                 }
10568                 {
10569                         uint32_t _flags_save_string = ndr->flags;
10570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10571                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10572                         if (_ptr_config_file) {
10573                                 NDR_PULL_ALLOC(ndr, r->config_file);
10574                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10575                         } else {
10576                                 r->config_file = NULL;
10577                         }
10578                         ndr->flags = _flags_save_string;
10579                 }
10580         }
10581         if (ndr_flags & NDR_BUFFERS) {
10582                 {
10583                         uint32_t _flags_save_string = ndr->flags;
10584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10585                         if (r->driver_name) {
10586                                 uint32_t _relative_save_offset;
10587                                 _relative_save_offset = ndr->offset;
10588                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10589                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10590                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10591                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10592                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10593                                 ndr->offset = _relative_save_offset;
10594                         }
10595                         ndr->flags = _flags_save_string;
10596                 }
10597                 {
10598                         uint32_t _flags_save_string = ndr->flags;
10599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10600                         if (r->architecture) {
10601                                 uint32_t _relative_save_offset;
10602                                 _relative_save_offset = ndr->offset;
10603                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10604                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10605                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10606                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10607                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10608                                 ndr->offset = _relative_save_offset;
10609                         }
10610                         ndr->flags = _flags_save_string;
10611                 }
10612                 {
10613                         uint32_t _flags_save_string = ndr->flags;
10614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10615                         if (r->driver_path) {
10616                                 uint32_t _relative_save_offset;
10617                                 _relative_save_offset = ndr->offset;
10618                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10619                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10620                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10621                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10622                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10623                                 ndr->offset = _relative_save_offset;
10624                         }
10625                         ndr->flags = _flags_save_string;
10626                 }
10627                 {
10628                         uint32_t _flags_save_string = ndr->flags;
10629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10630                         if (r->data_file) {
10631                                 uint32_t _relative_save_offset;
10632                                 _relative_save_offset = ndr->offset;
10633                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10634                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10635                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10636                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10637                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10638                                 ndr->offset = _relative_save_offset;
10639                         }
10640                         ndr->flags = _flags_save_string;
10641                 }
10642                 {
10643                         uint32_t _flags_save_string = ndr->flags;
10644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10645                         if (r->config_file) {
10646                                 uint32_t _relative_save_offset;
10647                                 _relative_save_offset = ndr->offset;
10648                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10649                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10650                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10651                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10652                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10653                                 ndr->offset = _relative_save_offset;
10654                         }
10655                         ndr->flags = _flags_save_string;
10656                 }
10657         }
10658         return NDR_ERR_SUCCESS;
10659 }
10660
10661 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10662 {
10663         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10664         ndr->depth++;
10665         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10666         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10667         ndr->depth++;
10668         if (r->driver_name) {
10669                 ndr_print_string(ndr, "driver_name", r->driver_name);
10670         }
10671         ndr->depth--;
10672         ndr_print_ptr(ndr, "architecture", r->architecture);
10673         ndr->depth++;
10674         if (r->architecture) {
10675                 ndr_print_string(ndr, "architecture", r->architecture);
10676         }
10677         ndr->depth--;
10678         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10679         ndr->depth++;
10680         if (r->driver_path) {
10681                 ndr_print_string(ndr, "driver_path", r->driver_path);
10682         }
10683         ndr->depth--;
10684         ndr_print_ptr(ndr, "data_file", r->data_file);
10685         ndr->depth++;
10686         if (r->data_file) {
10687                 ndr_print_string(ndr, "data_file", r->data_file);
10688         }
10689         ndr->depth--;
10690         ndr_print_ptr(ndr, "config_file", r->config_file);
10691         ndr->depth++;
10692         if (r->config_file) {
10693                 ndr_print_string(ndr, "config_file", r->config_file);
10694         }
10695         ndr->depth--;
10696         ndr->depth--;
10697 }
10698
10699 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10700 {
10701         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10702 }
10703
10704 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10705 {
10706         if (ndr_flags & NDR_SCALARS) {
10707                 NDR_CHECK(ndr_push_align(ndr, 5));
10708                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10709                 {
10710                         uint32_t _flags_save_string = ndr->flags;
10711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10712                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10713                         ndr->flags = _flags_save_string;
10714                 }
10715                 {
10716                         uint32_t _flags_save_string = ndr->flags;
10717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10718                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10719                         ndr->flags = _flags_save_string;
10720                 }
10721                 {
10722                         uint32_t _flags_save_string = ndr->flags;
10723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10724                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10725                         ndr->flags = _flags_save_string;
10726                 }
10727                 {
10728                         uint32_t _flags_save_string = ndr->flags;
10729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10730                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10737                         ndr->flags = _flags_save_string;
10738                 }
10739                 {
10740                         uint32_t _flags_save_string = ndr->flags;
10741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10742                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10743                         ndr->flags = _flags_save_string;
10744                 }
10745                 {
10746                         uint32_t _flags_save_string_array = ndr->flags;
10747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10748                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10749                         ndr->flags = _flags_save_string_array;
10750                 }
10751                 {
10752                         uint32_t _flags_save_string = ndr->flags;
10753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10754                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10755                         ndr->flags = _flags_save_string;
10756                 }
10757                 {
10758                         uint32_t _flags_save_string = ndr->flags;
10759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10760                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10761                         ndr->flags = _flags_save_string;
10762                 }
10763         }
10764         if (ndr_flags & NDR_BUFFERS) {
10765                 {
10766                         uint32_t _flags_save_string = ndr->flags;
10767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10768                         if (r->driver_name) {
10769                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10770                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10771                         }
10772                         ndr->flags = _flags_save_string;
10773                 }
10774                 {
10775                         uint32_t _flags_save_string = ndr->flags;
10776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10777                         if (r->architecture) {
10778                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10779                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10780                         }
10781                         ndr->flags = _flags_save_string;
10782                 }
10783                 {
10784                         uint32_t _flags_save_string = ndr->flags;
10785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10786                         if (r->driver_path) {
10787                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10788                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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                         if (r->data_file) {
10796                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10797                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10798                         }
10799                         ndr->flags = _flags_save_string;
10800                 }
10801                 {
10802                         uint32_t _flags_save_string = ndr->flags;
10803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10804                         if (r->config_file) {
10805                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10806                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10807                         }
10808                         ndr->flags = _flags_save_string;
10809                 }
10810                 {
10811                         uint32_t _flags_save_string = ndr->flags;
10812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10813                         if (r->help_file) {
10814                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10815                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10816                         }
10817                         ndr->flags = _flags_save_string;
10818                 }
10819                 {
10820                         uint32_t _flags_save_string_array = ndr->flags;
10821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10822                         if (r->dependent_files) {
10823                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10824                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10825                         }
10826                         ndr->flags = _flags_save_string_array;
10827                 }
10828                 {
10829                         uint32_t _flags_save_string = ndr->flags;
10830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10831                         if (r->monitor_name) {
10832                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10833                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10834                         }
10835                         ndr->flags = _flags_save_string;
10836                 }
10837                 {
10838                         uint32_t _flags_save_string = ndr->flags;
10839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10840                         if (r->default_datatype) {
10841                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10842                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10843                         }
10844                         ndr->flags = _flags_save_string;
10845                 }
10846         }
10847         return NDR_ERR_SUCCESS;
10848 }
10849
10850 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10851 {
10852         uint32_t _ptr_driver_name;
10853         TALLOC_CTX *_mem_save_driver_name_0;
10854         uint32_t _ptr_architecture;
10855         TALLOC_CTX *_mem_save_architecture_0;
10856         uint32_t _ptr_driver_path;
10857         TALLOC_CTX *_mem_save_driver_path_0;
10858         uint32_t _ptr_data_file;
10859         TALLOC_CTX *_mem_save_data_file_0;
10860         uint32_t _ptr_config_file;
10861         TALLOC_CTX *_mem_save_config_file_0;
10862         uint32_t _ptr_help_file;
10863         TALLOC_CTX *_mem_save_help_file_0;
10864         uint32_t _ptr_dependent_files;
10865         TALLOC_CTX *_mem_save_dependent_files_0;
10866         uint32_t _ptr_monitor_name;
10867         TALLOC_CTX *_mem_save_monitor_name_0;
10868         uint32_t _ptr_default_datatype;
10869         TALLOC_CTX *_mem_save_default_datatype_0;
10870         if (ndr_flags & NDR_SCALARS) {
10871                 NDR_CHECK(ndr_pull_align(ndr, 5));
10872                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10873                 {
10874                         uint32_t _flags_save_string = ndr->flags;
10875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10876                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10877                         if (_ptr_driver_name) {
10878                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10879                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10880                         } else {
10881                                 r->driver_name = NULL;
10882                         }
10883                         ndr->flags = _flags_save_string;
10884                 }
10885                 {
10886                         uint32_t _flags_save_string = ndr->flags;
10887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10888                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10889                         if (_ptr_architecture) {
10890                                 NDR_PULL_ALLOC(ndr, r->architecture);
10891                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10892                         } else {
10893                                 r->architecture = NULL;
10894                         }
10895                         ndr->flags = _flags_save_string;
10896                 }
10897                 {
10898                         uint32_t _flags_save_string = ndr->flags;
10899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10900                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10901                         if (_ptr_driver_path) {
10902                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10903                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10904                         } else {
10905                                 r->driver_path = NULL;
10906                         }
10907                         ndr->flags = _flags_save_string;
10908                 }
10909                 {
10910                         uint32_t _flags_save_string = ndr->flags;
10911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10912                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10913                         if (_ptr_data_file) {
10914                                 NDR_PULL_ALLOC(ndr, r->data_file);
10915                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10916                         } else {
10917                                 r->data_file = NULL;
10918                         }
10919                         ndr->flags = _flags_save_string;
10920                 }
10921                 {
10922                         uint32_t _flags_save_string = ndr->flags;
10923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10924                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10925                         if (_ptr_config_file) {
10926                                 NDR_PULL_ALLOC(ndr, r->config_file);
10927                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10928                         } else {
10929                                 r->config_file = NULL;
10930                         }
10931                         ndr->flags = _flags_save_string;
10932                 }
10933                 {
10934                         uint32_t _flags_save_string = ndr->flags;
10935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10936                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10937                         if (_ptr_help_file) {
10938                                 NDR_PULL_ALLOC(ndr, r->help_file);
10939                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10940                         } else {
10941                                 r->help_file = NULL;
10942                         }
10943                         ndr->flags = _flags_save_string;
10944                 }
10945                 {
10946                         uint32_t _flags_save_string_array = ndr->flags;
10947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10948                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10949                         if (_ptr_dependent_files) {
10950                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10951                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10952                         } else {
10953                                 r->dependent_files = NULL;
10954                         }
10955                         ndr->flags = _flags_save_string_array;
10956                 }
10957                 {
10958                         uint32_t _flags_save_string = ndr->flags;
10959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10960                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10961                         if (_ptr_monitor_name) {
10962                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10963                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10964                         } else {
10965                                 r->monitor_name = NULL;
10966                         }
10967                         ndr->flags = _flags_save_string;
10968                 }
10969                 {
10970                         uint32_t _flags_save_string = ndr->flags;
10971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10972                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10973                         if (_ptr_default_datatype) {
10974                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10975                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10976                         } else {
10977                                 r->default_datatype = NULL;
10978                         }
10979                         ndr->flags = _flags_save_string;
10980                 }
10981         }
10982         if (ndr_flags & NDR_BUFFERS) {
10983                 {
10984                         uint32_t _flags_save_string = ndr->flags;
10985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10986                         if (r->driver_name) {
10987                                 uint32_t _relative_save_offset;
10988                                 _relative_save_offset = ndr->offset;
10989                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10990                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10991                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10992                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10993                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10994                                 ndr->offset = _relative_save_offset;
10995                         }
10996                         ndr->flags = _flags_save_string;
10997                 }
10998                 {
10999                         uint32_t _flags_save_string = ndr->flags;
11000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11001                         if (r->architecture) {
11002                                 uint32_t _relative_save_offset;
11003                                 _relative_save_offset = ndr->offset;
11004                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11005                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11006                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11007                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11008                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11009                                 ndr->offset = _relative_save_offset;
11010                         }
11011                         ndr->flags = _flags_save_string;
11012                 }
11013                 {
11014                         uint32_t _flags_save_string = ndr->flags;
11015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11016                         if (r->driver_path) {
11017                                 uint32_t _relative_save_offset;
11018                                 _relative_save_offset = ndr->offset;
11019                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11020                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11021                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11022                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11023                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11024                                 ndr->offset = _relative_save_offset;
11025                         }
11026                         ndr->flags = _flags_save_string;
11027                 }
11028                 {
11029                         uint32_t _flags_save_string = ndr->flags;
11030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11031                         if (r->data_file) {
11032                                 uint32_t _relative_save_offset;
11033                                 _relative_save_offset = ndr->offset;
11034                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11035                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11036                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11037                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11038                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11039                                 ndr->offset = _relative_save_offset;
11040                         }
11041                         ndr->flags = _flags_save_string;
11042                 }
11043                 {
11044                         uint32_t _flags_save_string = ndr->flags;
11045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11046                         if (r->config_file) {
11047                                 uint32_t _relative_save_offset;
11048                                 _relative_save_offset = ndr->offset;
11049                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11050                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11051                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11052                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11053                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11054                                 ndr->offset = _relative_save_offset;
11055                         }
11056                         ndr->flags = _flags_save_string;
11057                 }
11058                 {
11059                         uint32_t _flags_save_string = ndr->flags;
11060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11061                         if (r->help_file) {
11062                                 uint32_t _relative_save_offset;
11063                                 _relative_save_offset = ndr->offset;
11064                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11065                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11066                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11067                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11068                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11069                                 ndr->offset = _relative_save_offset;
11070                         }
11071                         ndr->flags = _flags_save_string;
11072                 }
11073                 {
11074                         uint32_t _flags_save_string_array = ndr->flags;
11075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11076                         if (r->dependent_files) {
11077                                 uint32_t _relative_save_offset;
11078                                 _relative_save_offset = ndr->offset;
11079                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11080                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11081                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11082                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11083                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11084                                 ndr->offset = _relative_save_offset;
11085                         }
11086                         ndr->flags = _flags_save_string_array;
11087                 }
11088                 {
11089                         uint32_t _flags_save_string = ndr->flags;
11090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11091                         if (r->monitor_name) {
11092                                 uint32_t _relative_save_offset;
11093                                 _relative_save_offset = ndr->offset;
11094                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11095                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11096                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11097                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11098                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11099                                 ndr->offset = _relative_save_offset;
11100                         }
11101                         ndr->flags = _flags_save_string;
11102                 }
11103                 {
11104                         uint32_t _flags_save_string = ndr->flags;
11105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11106                         if (r->default_datatype) {
11107                                 uint32_t _relative_save_offset;
11108                                 _relative_save_offset = ndr->offset;
11109                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11110                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11111                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11112                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11113                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11114                                 ndr->offset = _relative_save_offset;
11115                         }
11116                         ndr->flags = _flags_save_string;
11117                 }
11118         }
11119         return NDR_ERR_SUCCESS;
11120 }
11121
11122 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11123 {
11124         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11125         ndr->depth++;
11126         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11127         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11128         ndr->depth++;
11129         if (r->driver_name) {
11130                 ndr_print_string(ndr, "driver_name", r->driver_name);
11131         }
11132         ndr->depth--;
11133         ndr_print_ptr(ndr, "architecture", r->architecture);
11134         ndr->depth++;
11135         if (r->architecture) {
11136                 ndr_print_string(ndr, "architecture", r->architecture);
11137         }
11138         ndr->depth--;
11139         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11140         ndr->depth++;
11141         if (r->driver_path) {
11142                 ndr_print_string(ndr, "driver_path", r->driver_path);
11143         }
11144         ndr->depth--;
11145         ndr_print_ptr(ndr, "data_file", r->data_file);
11146         ndr->depth++;
11147         if (r->data_file) {
11148                 ndr_print_string(ndr, "data_file", r->data_file);
11149         }
11150         ndr->depth--;
11151         ndr_print_ptr(ndr, "config_file", r->config_file);
11152         ndr->depth++;
11153         if (r->config_file) {
11154                 ndr_print_string(ndr, "config_file", r->config_file);
11155         }
11156         ndr->depth--;
11157         ndr_print_ptr(ndr, "help_file", r->help_file);
11158         ndr->depth++;
11159         if (r->help_file) {
11160                 ndr_print_string(ndr, "help_file", r->help_file);
11161         }
11162         ndr->depth--;
11163         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11164         ndr->depth++;
11165         if (r->dependent_files) {
11166                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11167         }
11168         ndr->depth--;
11169         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11170         ndr->depth++;
11171         if (r->monitor_name) {
11172                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11173         }
11174         ndr->depth--;
11175         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11176         ndr->depth++;
11177         if (r->default_datatype) {
11178                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11179         }
11180         ndr->depth--;
11181         ndr->depth--;
11182 }
11183
11184 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11185 {
11186         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11187 }
11188
11189 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11190 {
11191         if (ndr_flags & NDR_SCALARS) {
11192                 NDR_CHECK(ndr_push_align(ndr, 5));
11193                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11194                 {
11195                         uint32_t _flags_save_string = ndr->flags;
11196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11198                         ndr->flags = _flags_save_string;
11199                 }
11200                 {
11201                         uint32_t _flags_save_string = ndr->flags;
11202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11203                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11204                         ndr->flags = _flags_save_string;
11205                 }
11206                 {
11207                         uint32_t _flags_save_string = ndr->flags;
11208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11210                         ndr->flags = _flags_save_string;
11211                 }
11212                 {
11213                         uint32_t _flags_save_string = ndr->flags;
11214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11216                         ndr->flags = _flags_save_string;
11217                 }
11218                 {
11219                         uint32_t _flags_save_string = ndr->flags;
11220                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11221                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11222                         ndr->flags = _flags_save_string;
11223                 }
11224                 {
11225                         uint32_t _flags_save_string = ndr->flags;
11226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11227                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11228                         ndr->flags = _flags_save_string;
11229                 }
11230                 {
11231                         uint32_t _flags_save_string_array = ndr->flags;
11232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11233                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11234                         ndr->flags = _flags_save_string_array;
11235                 }
11236                 {
11237                         uint32_t _flags_save_string = ndr->flags;
11238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11239                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11240                         ndr->flags = _flags_save_string;
11241                 }
11242                 {
11243                         uint32_t _flags_save_string = ndr->flags;
11244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11245                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11246                         ndr->flags = _flags_save_string;
11247                 }
11248                 {
11249                         uint32_t _flags_save_string_array = ndr->flags;
11250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11251                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11252                         ndr->flags = _flags_save_string_array;
11253                 }
11254         }
11255         if (ndr_flags & NDR_BUFFERS) {
11256                 {
11257                         uint32_t _flags_save_string = ndr->flags;
11258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11259                         if (r->driver_name) {
11260                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11261                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11262                         }
11263                         ndr->flags = _flags_save_string;
11264                 }
11265                 {
11266                         uint32_t _flags_save_string = ndr->flags;
11267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11268                         if (r->architecture) {
11269                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11270                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11271                         }
11272                         ndr->flags = _flags_save_string;
11273                 }
11274                 {
11275                         uint32_t _flags_save_string = ndr->flags;
11276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11277                         if (r->driver_path) {
11278                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11279                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11280                         }
11281                         ndr->flags = _flags_save_string;
11282                 }
11283                 {
11284                         uint32_t _flags_save_string = ndr->flags;
11285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11286                         if (r->data_file) {
11287                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11288                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11289                         }
11290                         ndr->flags = _flags_save_string;
11291                 }
11292                 {
11293                         uint32_t _flags_save_string = ndr->flags;
11294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11295                         if (r->config_file) {
11296                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11297                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11298                         }
11299                         ndr->flags = _flags_save_string;
11300                 }
11301                 {
11302                         uint32_t _flags_save_string = ndr->flags;
11303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11304                         if (r->help_file) {
11305                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11306                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11307                         }
11308                         ndr->flags = _flags_save_string;
11309                 }
11310                 {
11311                         uint32_t _flags_save_string_array = ndr->flags;
11312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11313                         if (r->dependent_files) {
11314                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11315                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11316                         }
11317                         ndr->flags = _flags_save_string_array;
11318                 }
11319                 {
11320                         uint32_t _flags_save_string = ndr->flags;
11321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11322                         if (r->monitor_name) {
11323                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11324                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
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->default_datatype) {
11332                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11333                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11334                         }
11335                         ndr->flags = _flags_save_string;
11336                 }
11337                 {
11338                         uint32_t _flags_save_string_array = ndr->flags;
11339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11340                         if (r->previous_names) {
11341                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11342                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11343                         }
11344                         ndr->flags = _flags_save_string_array;
11345                 }
11346         }
11347         return NDR_ERR_SUCCESS;
11348 }
11349
11350 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11351 {
11352         uint32_t _ptr_driver_name;
11353         TALLOC_CTX *_mem_save_driver_name_0;
11354         uint32_t _ptr_architecture;
11355         TALLOC_CTX *_mem_save_architecture_0;
11356         uint32_t _ptr_driver_path;
11357         TALLOC_CTX *_mem_save_driver_path_0;
11358         uint32_t _ptr_data_file;
11359         TALLOC_CTX *_mem_save_data_file_0;
11360         uint32_t _ptr_config_file;
11361         TALLOC_CTX *_mem_save_config_file_0;
11362         uint32_t _ptr_help_file;
11363         TALLOC_CTX *_mem_save_help_file_0;
11364         uint32_t _ptr_dependent_files;
11365         TALLOC_CTX *_mem_save_dependent_files_0;
11366         uint32_t _ptr_monitor_name;
11367         TALLOC_CTX *_mem_save_monitor_name_0;
11368         uint32_t _ptr_default_datatype;
11369         TALLOC_CTX *_mem_save_default_datatype_0;
11370         uint32_t _ptr_previous_names;
11371         TALLOC_CTX *_mem_save_previous_names_0;
11372         if (ndr_flags & NDR_SCALARS) {
11373                 NDR_CHECK(ndr_pull_align(ndr, 5));
11374                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11375                 {
11376                         uint32_t _flags_save_string = ndr->flags;
11377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11378                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11379                         if (_ptr_driver_name) {
11380                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11381                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11382                         } else {
11383                                 r->driver_name = NULL;
11384                         }
11385                         ndr->flags = _flags_save_string;
11386                 }
11387                 {
11388                         uint32_t _flags_save_string = ndr->flags;
11389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11391                         if (_ptr_architecture) {
11392                                 NDR_PULL_ALLOC(ndr, r->architecture);
11393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11394                         } else {
11395                                 r->architecture = NULL;
11396                         }
11397                         ndr->flags = _flags_save_string;
11398                 }
11399                 {
11400                         uint32_t _flags_save_string = ndr->flags;
11401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11403                         if (_ptr_driver_path) {
11404                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11406                         } else {
11407                                 r->driver_path = NULL;
11408                         }
11409                         ndr->flags = _flags_save_string;
11410                 }
11411                 {
11412                         uint32_t _flags_save_string = ndr->flags;
11413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11414                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11415                         if (_ptr_data_file) {
11416                                 NDR_PULL_ALLOC(ndr, r->data_file);
11417                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11418                         } else {
11419                                 r->data_file = NULL;
11420                         }
11421                         ndr->flags = _flags_save_string;
11422                 }
11423                 {
11424                         uint32_t _flags_save_string = ndr->flags;
11425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11426                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11427                         if (_ptr_config_file) {
11428                                 NDR_PULL_ALLOC(ndr, r->config_file);
11429                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11430                         } else {
11431                                 r->config_file = NULL;
11432                         }
11433                         ndr->flags = _flags_save_string;
11434                 }
11435                 {
11436                         uint32_t _flags_save_string = ndr->flags;
11437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11438                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11439                         if (_ptr_help_file) {
11440                                 NDR_PULL_ALLOC(ndr, r->help_file);
11441                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11442                         } else {
11443                                 r->help_file = NULL;
11444                         }
11445                         ndr->flags = _flags_save_string;
11446                 }
11447                 {
11448                         uint32_t _flags_save_string_array = ndr->flags;
11449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11450                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11451                         if (_ptr_dependent_files) {
11452                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11453                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11454                         } else {
11455                                 r->dependent_files = NULL;
11456                         }
11457                         ndr->flags = _flags_save_string_array;
11458                 }
11459                 {
11460                         uint32_t _flags_save_string = ndr->flags;
11461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11462                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11463                         if (_ptr_monitor_name) {
11464                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11465                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11466                         } else {
11467                                 r->monitor_name = NULL;
11468                         }
11469                         ndr->flags = _flags_save_string;
11470                 }
11471                 {
11472                         uint32_t _flags_save_string = ndr->flags;
11473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11474                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11475                         if (_ptr_default_datatype) {
11476                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11477                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11478                         } else {
11479                                 r->default_datatype = NULL;
11480                         }
11481                         ndr->flags = _flags_save_string;
11482                 }
11483                 {
11484                         uint32_t _flags_save_string_array = ndr->flags;
11485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11486                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11487                         if (_ptr_previous_names) {
11488                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11489                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11490                         } else {
11491                                 r->previous_names = NULL;
11492                         }
11493                         ndr->flags = _flags_save_string_array;
11494                 }
11495         }
11496         if (ndr_flags & NDR_BUFFERS) {
11497                 {
11498                         uint32_t _flags_save_string = ndr->flags;
11499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11500                         if (r->driver_name) {
11501                                 uint32_t _relative_save_offset;
11502                                 _relative_save_offset = ndr->offset;
11503                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11504                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11505                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11506                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11507                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11508                                 ndr->offset = _relative_save_offset;
11509                         }
11510                         ndr->flags = _flags_save_string;
11511                 }
11512                 {
11513                         uint32_t _flags_save_string = ndr->flags;
11514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11515                         if (r->architecture) {
11516                                 uint32_t _relative_save_offset;
11517                                 _relative_save_offset = ndr->offset;
11518                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11519                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11520                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11521                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11522                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11523                                 ndr->offset = _relative_save_offset;
11524                         }
11525                         ndr->flags = _flags_save_string;
11526                 }
11527                 {
11528                         uint32_t _flags_save_string = ndr->flags;
11529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11530                         if (r->driver_path) {
11531                                 uint32_t _relative_save_offset;
11532                                 _relative_save_offset = ndr->offset;
11533                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11534                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11535                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11536                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11537                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11538                                 ndr->offset = _relative_save_offset;
11539                         }
11540                         ndr->flags = _flags_save_string;
11541                 }
11542                 {
11543                         uint32_t _flags_save_string = ndr->flags;
11544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11545                         if (r->data_file) {
11546                                 uint32_t _relative_save_offset;
11547                                 _relative_save_offset = ndr->offset;
11548                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11549                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11550                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11551                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11552                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11553                                 ndr->offset = _relative_save_offset;
11554                         }
11555                         ndr->flags = _flags_save_string;
11556                 }
11557                 {
11558                         uint32_t _flags_save_string = ndr->flags;
11559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11560                         if (r->config_file) {
11561                                 uint32_t _relative_save_offset;
11562                                 _relative_save_offset = ndr->offset;
11563                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11564                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11565                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11566                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11567                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11568                                 ndr->offset = _relative_save_offset;
11569                         }
11570                         ndr->flags = _flags_save_string;
11571                 }
11572                 {
11573                         uint32_t _flags_save_string = ndr->flags;
11574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11575                         if (r->help_file) {
11576                                 uint32_t _relative_save_offset;
11577                                 _relative_save_offset = ndr->offset;
11578                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11579                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11580                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11581                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11582                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11583                                 ndr->offset = _relative_save_offset;
11584                         }
11585                         ndr->flags = _flags_save_string;
11586                 }
11587                 {
11588                         uint32_t _flags_save_string_array = ndr->flags;
11589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11590                         if (r->dependent_files) {
11591                                 uint32_t _relative_save_offset;
11592                                 _relative_save_offset = ndr->offset;
11593                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11594                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11595                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11596                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11597                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11598                                 ndr->offset = _relative_save_offset;
11599                         }
11600                         ndr->flags = _flags_save_string_array;
11601                 }
11602                 {
11603                         uint32_t _flags_save_string = ndr->flags;
11604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11605                         if (r->monitor_name) {
11606                                 uint32_t _relative_save_offset;
11607                                 _relative_save_offset = ndr->offset;
11608                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11609                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11610                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11613                                 ndr->offset = _relative_save_offset;
11614                         }
11615                         ndr->flags = _flags_save_string;
11616                 }
11617                 {
11618                         uint32_t _flags_save_string = ndr->flags;
11619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11620                         if (r->default_datatype) {
11621                                 uint32_t _relative_save_offset;
11622                                 _relative_save_offset = ndr->offset;
11623                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11624                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11625                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11626                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11627                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11628                                 ndr->offset = _relative_save_offset;
11629                         }
11630                         ndr->flags = _flags_save_string;
11631                 }
11632                 {
11633                         uint32_t _flags_save_string_array = ndr->flags;
11634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11635                         if (r->previous_names) {
11636                                 uint32_t _relative_save_offset;
11637                                 _relative_save_offset = ndr->offset;
11638                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11639                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11640                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11641                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11642                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11643                                 ndr->offset = _relative_save_offset;
11644                         }
11645                         ndr->flags = _flags_save_string_array;
11646                 }
11647         }
11648         return NDR_ERR_SUCCESS;
11649 }
11650
11651 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11652 {
11653         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11654         ndr->depth++;
11655         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11656         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11657         ndr->depth++;
11658         if (r->driver_name) {
11659                 ndr_print_string(ndr, "driver_name", r->driver_name);
11660         }
11661         ndr->depth--;
11662         ndr_print_ptr(ndr, "architecture", r->architecture);
11663         ndr->depth++;
11664         if (r->architecture) {
11665                 ndr_print_string(ndr, "architecture", r->architecture);
11666         }
11667         ndr->depth--;
11668         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11669         ndr->depth++;
11670         if (r->driver_path) {
11671                 ndr_print_string(ndr, "driver_path", r->driver_path);
11672         }
11673         ndr->depth--;
11674         ndr_print_ptr(ndr, "data_file", r->data_file);
11675         ndr->depth++;
11676         if (r->data_file) {
11677                 ndr_print_string(ndr, "data_file", r->data_file);
11678         }
11679         ndr->depth--;
11680         ndr_print_ptr(ndr, "config_file", r->config_file);
11681         ndr->depth++;
11682         if (r->config_file) {
11683                 ndr_print_string(ndr, "config_file", r->config_file);
11684         }
11685         ndr->depth--;
11686         ndr_print_ptr(ndr, "help_file", r->help_file);
11687         ndr->depth++;
11688         if (r->help_file) {
11689                 ndr_print_string(ndr, "help_file", r->help_file);
11690         }
11691         ndr->depth--;
11692         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11693         ndr->depth++;
11694         if (r->dependent_files) {
11695                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11696         }
11697         ndr->depth--;
11698         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11699         ndr->depth++;
11700         if (r->monitor_name) {
11701                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11702         }
11703         ndr->depth--;
11704         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11705         ndr->depth++;
11706         if (r->default_datatype) {
11707                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11708         }
11709         ndr->depth--;
11710         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11711         ndr->depth++;
11712         if (r->previous_names) {
11713                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11714         }
11715         ndr->depth--;
11716         ndr->depth--;
11717 }
11718
11719 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11720 {
11721         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11722 }
11723
11724 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11725 {
11726         if (ndr_flags & NDR_SCALARS) {
11727                 NDR_CHECK(ndr_push_align(ndr, 5));
11728                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11729                 {
11730                         uint32_t _flags_save_string = ndr->flags;
11731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11732                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11733                         ndr->flags = _flags_save_string;
11734                 }
11735                 {
11736                         uint32_t _flags_save_string = ndr->flags;
11737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11738                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11739                         ndr->flags = _flags_save_string;
11740                 }
11741                 {
11742                         uint32_t _flags_save_string = ndr->flags;
11743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11745                         ndr->flags = _flags_save_string;
11746                 }
11747                 {
11748                         uint32_t _flags_save_string = ndr->flags;
11749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11751                         ndr->flags = _flags_save_string;
11752                 }
11753                 {
11754                         uint32_t _flags_save_string = ndr->flags;
11755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11756                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11757                         ndr->flags = _flags_save_string;
11758                 }
11759                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
11760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11762         }
11763         if (ndr_flags & NDR_BUFFERS) {
11764                 {
11765                         uint32_t _flags_save_string = ndr->flags;
11766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11767                         if (r->driver_name) {
11768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11770                         }
11771                         ndr->flags = _flags_save_string;
11772                 }
11773                 {
11774                         uint32_t _flags_save_string = ndr->flags;
11775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11776                         if (r->architecture) {
11777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11779                         }
11780                         ndr->flags = _flags_save_string;
11781                 }
11782                 {
11783                         uint32_t _flags_save_string = ndr->flags;
11784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11785                         if (r->driver_path) {
11786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11788                         }
11789                         ndr->flags = _flags_save_string;
11790                 }
11791                 {
11792                         uint32_t _flags_save_string = ndr->flags;
11793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11794                         if (r->data_file) {
11795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11797                         }
11798                         ndr->flags = _flags_save_string;
11799                 }
11800                 {
11801                         uint32_t _flags_save_string = ndr->flags;
11802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11803                         if (r->config_file) {
11804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11806                         }
11807                         ndr->flags = _flags_save_string;
11808                 }
11809         }
11810         return NDR_ERR_SUCCESS;
11811 }
11812
11813 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11814 {
11815         uint32_t _ptr_driver_name;
11816         TALLOC_CTX *_mem_save_driver_name_0;
11817         uint32_t _ptr_architecture;
11818         TALLOC_CTX *_mem_save_architecture_0;
11819         uint32_t _ptr_driver_path;
11820         TALLOC_CTX *_mem_save_driver_path_0;
11821         uint32_t _ptr_data_file;
11822         TALLOC_CTX *_mem_save_data_file_0;
11823         uint32_t _ptr_config_file;
11824         TALLOC_CTX *_mem_save_config_file_0;
11825         if (ndr_flags & NDR_SCALARS) {
11826                 NDR_CHECK(ndr_pull_align(ndr, 5));
11827                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11828                 {
11829                         uint32_t _flags_save_string = ndr->flags;
11830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11832                         if (_ptr_driver_name) {
11833                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11835                         } else {
11836                                 r->driver_name = NULL;
11837                         }
11838                         ndr->flags = _flags_save_string;
11839                 }
11840                 {
11841                         uint32_t _flags_save_string = ndr->flags;
11842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11843                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11844                         if (_ptr_architecture) {
11845                                 NDR_PULL_ALLOC(ndr, r->architecture);
11846                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11847                         } else {
11848                                 r->architecture = NULL;
11849                         }
11850                         ndr->flags = _flags_save_string;
11851                 }
11852                 {
11853                         uint32_t _flags_save_string = ndr->flags;
11854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11856                         if (_ptr_driver_path) {
11857                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11859                         } else {
11860                                 r->driver_path = NULL;
11861                         }
11862                         ndr->flags = _flags_save_string;
11863                 }
11864                 {
11865                         uint32_t _flags_save_string = ndr->flags;
11866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11867                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11868                         if (_ptr_data_file) {
11869                                 NDR_PULL_ALLOC(ndr, r->data_file);
11870                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11871                         } else {
11872                                 r->data_file = NULL;
11873                         }
11874                         ndr->flags = _flags_save_string;
11875                 }
11876                 {
11877                         uint32_t _flags_save_string = ndr->flags;
11878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11879                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11880                         if (_ptr_config_file) {
11881                                 NDR_PULL_ALLOC(ndr, r->config_file);
11882                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11883                         } else {
11884                                 r->config_file = NULL;
11885                         }
11886                         ndr->flags = _flags_save_string;
11887                 }
11888                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
11889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11891         }
11892         if (ndr_flags & NDR_BUFFERS) {
11893                 {
11894                         uint32_t _flags_save_string = ndr->flags;
11895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11896                         if (r->driver_name) {
11897                                 uint32_t _relative_save_offset;
11898                                 _relative_save_offset = ndr->offset;
11899                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11900                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11901                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11902                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11903                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11904                                 ndr->offset = _relative_save_offset;
11905                         }
11906                         ndr->flags = _flags_save_string;
11907                 }
11908                 {
11909                         uint32_t _flags_save_string = ndr->flags;
11910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11911                         if (r->architecture) {
11912                                 uint32_t _relative_save_offset;
11913                                 _relative_save_offset = ndr->offset;
11914                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11915                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11916                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11917                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11918                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11919                                 ndr->offset = _relative_save_offset;
11920                         }
11921                         ndr->flags = _flags_save_string;
11922                 }
11923                 {
11924                         uint32_t _flags_save_string = ndr->flags;
11925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11926                         if (r->driver_path) {
11927                                 uint32_t _relative_save_offset;
11928                                 _relative_save_offset = ndr->offset;
11929                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11930                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11931                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11932                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11933                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11934                                 ndr->offset = _relative_save_offset;
11935                         }
11936                         ndr->flags = _flags_save_string;
11937                 }
11938                 {
11939                         uint32_t _flags_save_string = ndr->flags;
11940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11941                         if (r->data_file) {
11942                                 uint32_t _relative_save_offset;
11943                                 _relative_save_offset = ndr->offset;
11944                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11945                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11946                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11947                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11948                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11949                                 ndr->offset = _relative_save_offset;
11950                         }
11951                         ndr->flags = _flags_save_string;
11952                 }
11953                 {
11954                         uint32_t _flags_save_string = ndr->flags;
11955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11956                         if (r->config_file) {
11957                                 uint32_t _relative_save_offset;
11958                                 _relative_save_offset = ndr->offset;
11959                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11960                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11961                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11962                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11963                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11964                                 ndr->offset = _relative_save_offset;
11965                         }
11966                         ndr->flags = _flags_save_string;
11967                 }
11968         }
11969         return NDR_ERR_SUCCESS;
11970 }
11971
11972 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11973 {
11974         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11975         ndr->depth++;
11976         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11977         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11978         ndr->depth++;
11979         if (r->driver_name) {
11980                 ndr_print_string(ndr, "driver_name", r->driver_name);
11981         }
11982         ndr->depth--;
11983         ndr_print_ptr(ndr, "architecture", r->architecture);
11984         ndr->depth++;
11985         if (r->architecture) {
11986                 ndr_print_string(ndr, "architecture", r->architecture);
11987         }
11988         ndr->depth--;
11989         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11990         ndr->depth++;
11991         if (r->driver_path) {
11992                 ndr_print_string(ndr, "driver_path", r->driver_path);
11993         }
11994         ndr->depth--;
11995         ndr_print_ptr(ndr, "data_file", r->data_file);
11996         ndr->depth++;
11997         if (r->data_file) {
11998                 ndr_print_string(ndr, "data_file", r->data_file);
11999         }
12000         ndr->depth--;
12001         ndr_print_ptr(ndr, "config_file", r->config_file);
12002         ndr->depth++;
12003         if (r->config_file) {
12004                 ndr_print_string(ndr, "config_file", r->config_file);
12005         }
12006         ndr->depth--;
12007         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12008         ndr_print_uint32(ndr, "config_version", r->config_version);
12009         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12010         ndr->depth--;
12011 }
12012
12013 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12014 {
12015         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12016 }
12017
12018 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12019 {
12020         if (ndr_flags & NDR_SCALARS) {
12021                 NDR_CHECK(ndr_push_align(ndr, 8));
12022                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12023                 {
12024                         uint32_t _flags_save_string = ndr->flags;
12025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12026                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12027                         ndr->flags = _flags_save_string;
12028                 }
12029                 {
12030                         uint32_t _flags_save_string = ndr->flags;
12031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12032                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12033                         ndr->flags = _flags_save_string;
12034                 }
12035                 {
12036                         uint32_t _flags_save_string = ndr->flags;
12037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12039                         ndr->flags = _flags_save_string;
12040                 }
12041                 {
12042                         uint32_t _flags_save_string = ndr->flags;
12043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12045                         ndr->flags = _flags_save_string;
12046                 }
12047                 {
12048                         uint32_t _flags_save_string = ndr->flags;
12049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12051                         ndr->flags = _flags_save_string;
12052                 }
12053                 {
12054                         uint32_t _flags_save_string = ndr->flags;
12055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12057                         ndr->flags = _flags_save_string;
12058                 }
12059                 {
12060                         uint32_t _flags_save_string_array = ndr->flags;
12061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12062                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12063                         ndr->flags = _flags_save_string_array;
12064                 }
12065                 {
12066                         uint32_t _flags_save_string = ndr->flags;
12067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12068                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12069                         ndr->flags = _flags_save_string;
12070                 }
12071                 {
12072                         uint32_t _flags_save_string = ndr->flags;
12073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12074                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12075                         ndr->flags = _flags_save_string;
12076                 }
12077                 {
12078                         uint32_t _flags_save_string_array = ndr->flags;
12079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12080                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12081                         ndr->flags = _flags_save_string_array;
12082                 }
12083                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12084                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12085                 {
12086                         uint32_t _flags_save_string = ndr->flags;
12087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12088                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12089                         ndr->flags = _flags_save_string;
12090                 }
12091                 {
12092                         uint32_t _flags_save_string = ndr->flags;
12093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12094                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12095                         ndr->flags = _flags_save_string;
12096                 }
12097                 {
12098                         uint32_t _flags_save_string = ndr->flags;
12099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12100                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12101                         ndr->flags = _flags_save_string;
12102                 }
12103                 {
12104                         uint32_t _flags_save_string = ndr->flags;
12105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12106                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12107                         ndr->flags = _flags_save_string;
12108                 }
12109         }
12110         if (ndr_flags & NDR_BUFFERS) {
12111                 {
12112                         uint32_t _flags_save_string = ndr->flags;
12113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12114                         if (r->driver_name) {
12115                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12116                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12117                         }
12118                         ndr->flags = _flags_save_string;
12119                 }
12120                 {
12121                         uint32_t _flags_save_string = ndr->flags;
12122                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12123                         if (r->architecture) {
12124                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12125                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12126                         }
12127                         ndr->flags = _flags_save_string;
12128                 }
12129                 {
12130                         uint32_t _flags_save_string = ndr->flags;
12131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12132                         if (r->driver_path) {
12133                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12134                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12135                         }
12136                         ndr->flags = _flags_save_string;
12137                 }
12138                 {
12139                         uint32_t _flags_save_string = ndr->flags;
12140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12141                         if (r->data_file) {
12142                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12143                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12144                         }
12145                         ndr->flags = _flags_save_string;
12146                 }
12147                 {
12148                         uint32_t _flags_save_string = ndr->flags;
12149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12150                         if (r->config_file) {
12151                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12152                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12153                         }
12154                         ndr->flags = _flags_save_string;
12155                 }
12156                 {
12157                         uint32_t _flags_save_string = ndr->flags;
12158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12159                         if (r->help_file) {
12160                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12161                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12162                         }
12163                         ndr->flags = _flags_save_string;
12164                 }
12165                 {
12166                         uint32_t _flags_save_string_array = ndr->flags;
12167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12168                         if (r->dependent_files) {
12169                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12170                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12171                         }
12172                         ndr->flags = _flags_save_string_array;
12173                 }
12174                 {
12175                         uint32_t _flags_save_string = ndr->flags;
12176                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12177                         if (r->monitor_name) {
12178                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12179                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12180                         }
12181                         ndr->flags = _flags_save_string;
12182                 }
12183                 {
12184                         uint32_t _flags_save_string = ndr->flags;
12185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12186                         if (r->default_datatype) {
12187                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12188                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12189                         }
12190                         ndr->flags = _flags_save_string;
12191                 }
12192                 {
12193                         uint32_t _flags_save_string_array = ndr->flags;
12194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12195                         if (r->previous_names) {
12196                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12197                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12198                         }
12199                         ndr->flags = _flags_save_string_array;
12200                 }
12201                 {
12202                         uint32_t _flags_save_string = ndr->flags;
12203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12204                         if (r->manufacturer_name) {
12205                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12206                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12207                         }
12208                         ndr->flags = _flags_save_string;
12209                 }
12210                 {
12211                         uint32_t _flags_save_string = ndr->flags;
12212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12213                         if (r->manufacturer_url) {
12214                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12215                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12216                         }
12217                         ndr->flags = _flags_save_string;
12218                 }
12219                 {
12220                         uint32_t _flags_save_string = ndr->flags;
12221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12222                         if (r->hardware_id) {
12223                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12224                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12225                         }
12226                         ndr->flags = _flags_save_string;
12227                 }
12228                 {
12229                         uint32_t _flags_save_string = ndr->flags;
12230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12231                         if (r->provider) {
12232                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12233                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12234                         }
12235                         ndr->flags = _flags_save_string;
12236                 }
12237         }
12238         return NDR_ERR_SUCCESS;
12239 }
12240
12241 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12242 {
12243         uint32_t _ptr_driver_name;
12244         TALLOC_CTX *_mem_save_driver_name_0;
12245         uint32_t _ptr_architecture;
12246         TALLOC_CTX *_mem_save_architecture_0;
12247         uint32_t _ptr_driver_path;
12248         TALLOC_CTX *_mem_save_driver_path_0;
12249         uint32_t _ptr_data_file;
12250         TALLOC_CTX *_mem_save_data_file_0;
12251         uint32_t _ptr_config_file;
12252         TALLOC_CTX *_mem_save_config_file_0;
12253         uint32_t _ptr_help_file;
12254         TALLOC_CTX *_mem_save_help_file_0;
12255         uint32_t _ptr_dependent_files;
12256         TALLOC_CTX *_mem_save_dependent_files_0;
12257         uint32_t _ptr_monitor_name;
12258         TALLOC_CTX *_mem_save_monitor_name_0;
12259         uint32_t _ptr_default_datatype;
12260         TALLOC_CTX *_mem_save_default_datatype_0;
12261         uint32_t _ptr_previous_names;
12262         TALLOC_CTX *_mem_save_previous_names_0;
12263         uint32_t _ptr_manufacturer_name;
12264         TALLOC_CTX *_mem_save_manufacturer_name_0;
12265         uint32_t _ptr_manufacturer_url;
12266         TALLOC_CTX *_mem_save_manufacturer_url_0;
12267         uint32_t _ptr_hardware_id;
12268         TALLOC_CTX *_mem_save_hardware_id_0;
12269         uint32_t _ptr_provider;
12270         TALLOC_CTX *_mem_save_provider_0;
12271         if (ndr_flags & NDR_SCALARS) {
12272                 NDR_CHECK(ndr_pull_align(ndr, 8));
12273                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12274                 {
12275                         uint32_t _flags_save_string = ndr->flags;
12276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12277                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12278                         if (_ptr_driver_name) {
12279                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12280                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12281                         } else {
12282                                 r->driver_name = NULL;
12283                         }
12284                         ndr->flags = _flags_save_string;
12285                 }
12286                 {
12287                         uint32_t _flags_save_string = ndr->flags;
12288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12289                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12290                         if (_ptr_architecture) {
12291                                 NDR_PULL_ALLOC(ndr, r->architecture);
12292                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12293                         } else {
12294                                 r->architecture = NULL;
12295                         }
12296                         ndr->flags = _flags_save_string;
12297                 }
12298                 {
12299                         uint32_t _flags_save_string = ndr->flags;
12300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12301                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12302                         if (_ptr_driver_path) {
12303                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12304                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12305                         } else {
12306                                 r->driver_path = NULL;
12307                         }
12308                         ndr->flags = _flags_save_string;
12309                 }
12310                 {
12311                         uint32_t _flags_save_string = ndr->flags;
12312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12313                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12314                         if (_ptr_data_file) {
12315                                 NDR_PULL_ALLOC(ndr, r->data_file);
12316                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12317                         } else {
12318                                 r->data_file = NULL;
12319                         }
12320                         ndr->flags = _flags_save_string;
12321                 }
12322                 {
12323                         uint32_t _flags_save_string = ndr->flags;
12324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12325                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12326                         if (_ptr_config_file) {
12327                                 NDR_PULL_ALLOC(ndr, r->config_file);
12328                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12329                         } else {
12330                                 r->config_file = NULL;
12331                         }
12332                         ndr->flags = _flags_save_string;
12333                 }
12334                 {
12335                         uint32_t _flags_save_string = ndr->flags;
12336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12337                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12338                         if (_ptr_help_file) {
12339                                 NDR_PULL_ALLOC(ndr, r->help_file);
12340                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12341                         } else {
12342                                 r->help_file = NULL;
12343                         }
12344                         ndr->flags = _flags_save_string;
12345                 }
12346                 {
12347                         uint32_t _flags_save_string_array = ndr->flags;
12348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12349                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12350                         if (_ptr_dependent_files) {
12351                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12352                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12353                         } else {
12354                                 r->dependent_files = NULL;
12355                         }
12356                         ndr->flags = _flags_save_string_array;
12357                 }
12358                 {
12359                         uint32_t _flags_save_string = ndr->flags;
12360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12361                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12362                         if (_ptr_monitor_name) {
12363                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12364                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12365                         } else {
12366                                 r->monitor_name = NULL;
12367                         }
12368                         ndr->flags = _flags_save_string;
12369                 }
12370                 {
12371                         uint32_t _flags_save_string = ndr->flags;
12372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12373                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12374                         if (_ptr_default_datatype) {
12375                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12376                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12377                         } else {
12378                                 r->default_datatype = NULL;
12379                         }
12380                         ndr->flags = _flags_save_string;
12381                 }
12382                 {
12383                         uint32_t _flags_save_string_array = ndr->flags;
12384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12386                         if (_ptr_previous_names) {
12387                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12389                         } else {
12390                                 r->previous_names = NULL;
12391                         }
12392                         ndr->flags = _flags_save_string_array;
12393                 }
12394                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12395                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12396                 {
12397                         uint32_t _flags_save_string = ndr->flags;
12398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12399                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12400                         if (_ptr_manufacturer_name) {
12401                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12402                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12403                         } else {
12404                                 r->manufacturer_name = NULL;
12405                         }
12406                         ndr->flags = _flags_save_string;
12407                 }
12408                 {
12409                         uint32_t _flags_save_string = ndr->flags;
12410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12411                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12412                         if (_ptr_manufacturer_url) {
12413                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12414                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12415                         } else {
12416                                 r->manufacturer_url = NULL;
12417                         }
12418                         ndr->flags = _flags_save_string;
12419                 }
12420                 {
12421                         uint32_t _flags_save_string = ndr->flags;
12422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12423                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12424                         if (_ptr_hardware_id) {
12425                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12426                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12427                         } else {
12428                                 r->hardware_id = NULL;
12429                         }
12430                         ndr->flags = _flags_save_string;
12431                 }
12432                 {
12433                         uint32_t _flags_save_string = ndr->flags;
12434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12435                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12436                         if (_ptr_provider) {
12437                                 NDR_PULL_ALLOC(ndr, r->provider);
12438                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12439                         } else {
12440                                 r->provider = NULL;
12441                         }
12442                         ndr->flags = _flags_save_string;
12443                 }
12444         }
12445         if (ndr_flags & NDR_BUFFERS) {
12446                 {
12447                         uint32_t _flags_save_string = ndr->flags;
12448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12449                         if (r->driver_name) {
12450                                 uint32_t _relative_save_offset;
12451                                 _relative_save_offset = ndr->offset;
12452                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12453                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12454                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12455                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12456                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12457                                 ndr->offset = _relative_save_offset;
12458                         }
12459                         ndr->flags = _flags_save_string;
12460                 }
12461                 {
12462                         uint32_t _flags_save_string = ndr->flags;
12463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12464                         if (r->architecture) {
12465                                 uint32_t _relative_save_offset;
12466                                 _relative_save_offset = ndr->offset;
12467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12468                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12469                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12472                                 ndr->offset = _relative_save_offset;
12473                         }
12474                         ndr->flags = _flags_save_string;
12475                 }
12476                 {
12477                         uint32_t _flags_save_string = ndr->flags;
12478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12479                         if (r->driver_path) {
12480                                 uint32_t _relative_save_offset;
12481                                 _relative_save_offset = ndr->offset;
12482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12483                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12484                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12487                                 ndr->offset = _relative_save_offset;
12488                         }
12489                         ndr->flags = _flags_save_string;
12490                 }
12491                 {
12492                         uint32_t _flags_save_string = ndr->flags;
12493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12494                         if (r->data_file) {
12495                                 uint32_t _relative_save_offset;
12496                                 _relative_save_offset = ndr->offset;
12497                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12498                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12499                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12500                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12501                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12502                                 ndr->offset = _relative_save_offset;
12503                         }
12504                         ndr->flags = _flags_save_string;
12505                 }
12506                 {
12507                         uint32_t _flags_save_string = ndr->flags;
12508                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12509                         if (r->config_file) {
12510                                 uint32_t _relative_save_offset;
12511                                 _relative_save_offset = ndr->offset;
12512                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12513                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12514                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12515                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12516                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12517                                 ndr->offset = _relative_save_offset;
12518                         }
12519                         ndr->flags = _flags_save_string;
12520                 }
12521                 {
12522                         uint32_t _flags_save_string = ndr->flags;
12523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12524                         if (r->help_file) {
12525                                 uint32_t _relative_save_offset;
12526                                 _relative_save_offset = ndr->offset;
12527                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12528                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12529                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12530                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12531                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12532                                 ndr->offset = _relative_save_offset;
12533                         }
12534                         ndr->flags = _flags_save_string;
12535                 }
12536                 {
12537                         uint32_t _flags_save_string_array = ndr->flags;
12538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12539                         if (r->dependent_files) {
12540                                 uint32_t _relative_save_offset;
12541                                 _relative_save_offset = ndr->offset;
12542                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12543                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12544                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12545                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12546                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12547                                 ndr->offset = _relative_save_offset;
12548                         }
12549                         ndr->flags = _flags_save_string_array;
12550                 }
12551                 {
12552                         uint32_t _flags_save_string = ndr->flags;
12553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12554                         if (r->monitor_name) {
12555                                 uint32_t _relative_save_offset;
12556                                 _relative_save_offset = ndr->offset;
12557                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12558                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12559                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12560                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12561                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12562                                 ndr->offset = _relative_save_offset;
12563                         }
12564                         ndr->flags = _flags_save_string;
12565                 }
12566                 {
12567                         uint32_t _flags_save_string = ndr->flags;
12568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12569                         if (r->default_datatype) {
12570                                 uint32_t _relative_save_offset;
12571                                 _relative_save_offset = ndr->offset;
12572                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12573                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12574                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12575                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12576                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12577                                 ndr->offset = _relative_save_offset;
12578                         }
12579                         ndr->flags = _flags_save_string;
12580                 }
12581                 {
12582                         uint32_t _flags_save_string_array = ndr->flags;
12583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12584                         if (r->previous_names) {
12585                                 uint32_t _relative_save_offset;
12586                                 _relative_save_offset = ndr->offset;
12587                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12588                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12589                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12590                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12591                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12592                                 ndr->offset = _relative_save_offset;
12593                         }
12594                         ndr->flags = _flags_save_string_array;
12595                 }
12596                 {
12597                         uint32_t _flags_save_string = ndr->flags;
12598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12599                         if (r->manufacturer_name) {
12600                                 uint32_t _relative_save_offset;
12601                                 _relative_save_offset = ndr->offset;
12602                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12603                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12604                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12605                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12606                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12607                                 ndr->offset = _relative_save_offset;
12608                         }
12609                         ndr->flags = _flags_save_string;
12610                 }
12611                 {
12612                         uint32_t _flags_save_string = ndr->flags;
12613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12614                         if (r->manufacturer_url) {
12615                                 uint32_t _relative_save_offset;
12616                                 _relative_save_offset = ndr->offset;
12617                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12618                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12619                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12620                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12621                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12622                                 ndr->offset = _relative_save_offset;
12623                         }
12624                         ndr->flags = _flags_save_string;
12625                 }
12626                 {
12627                         uint32_t _flags_save_string = ndr->flags;
12628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12629                         if (r->hardware_id) {
12630                                 uint32_t _relative_save_offset;
12631                                 _relative_save_offset = ndr->offset;
12632                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12633                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12634                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12635                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12636                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12637                                 ndr->offset = _relative_save_offset;
12638                         }
12639                         ndr->flags = _flags_save_string;
12640                 }
12641                 {
12642                         uint32_t _flags_save_string = ndr->flags;
12643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12644                         if (r->provider) {
12645                                 uint32_t _relative_save_offset;
12646                                 _relative_save_offset = ndr->offset;
12647                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12648                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12649                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12650                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12651                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12652                                 ndr->offset = _relative_save_offset;
12653                         }
12654                         ndr->flags = _flags_save_string;
12655                 }
12656         }
12657         return NDR_ERR_SUCCESS;
12658 }
12659
12660 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12661 {
12662         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12663         ndr->depth++;
12664         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12665         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12666         ndr->depth++;
12667         if (r->driver_name) {
12668                 ndr_print_string(ndr, "driver_name", r->driver_name);
12669         }
12670         ndr->depth--;
12671         ndr_print_ptr(ndr, "architecture", r->architecture);
12672         ndr->depth++;
12673         if (r->architecture) {
12674                 ndr_print_string(ndr, "architecture", r->architecture);
12675         }
12676         ndr->depth--;
12677         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12678         ndr->depth++;
12679         if (r->driver_path) {
12680                 ndr_print_string(ndr, "driver_path", r->driver_path);
12681         }
12682         ndr->depth--;
12683         ndr_print_ptr(ndr, "data_file", r->data_file);
12684         ndr->depth++;
12685         if (r->data_file) {
12686                 ndr_print_string(ndr, "data_file", r->data_file);
12687         }
12688         ndr->depth--;
12689         ndr_print_ptr(ndr, "config_file", r->config_file);
12690         ndr->depth++;
12691         if (r->config_file) {
12692                 ndr_print_string(ndr, "config_file", r->config_file);
12693         }
12694         ndr->depth--;
12695         ndr_print_ptr(ndr, "help_file", r->help_file);
12696         ndr->depth++;
12697         if (r->help_file) {
12698                 ndr_print_string(ndr, "help_file", r->help_file);
12699         }
12700         ndr->depth--;
12701         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12702         ndr->depth++;
12703         if (r->dependent_files) {
12704                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12705         }
12706         ndr->depth--;
12707         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12708         ndr->depth++;
12709         if (r->monitor_name) {
12710                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12711         }
12712         ndr->depth--;
12713         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12714         ndr->depth++;
12715         if (r->default_datatype) {
12716                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12717         }
12718         ndr->depth--;
12719         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12720         ndr->depth++;
12721         if (r->previous_names) {
12722                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12723         }
12724         ndr->depth--;
12725         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12726         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12727         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12728         ndr->depth++;
12729         if (r->manufacturer_name) {
12730                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12731         }
12732         ndr->depth--;
12733         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12734         ndr->depth++;
12735         if (r->manufacturer_url) {
12736                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12737         }
12738         ndr->depth--;
12739         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12740         ndr->depth++;
12741         if (r->hardware_id) {
12742                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12743         }
12744         ndr->depth--;
12745         ndr_print_ptr(ndr, "provider", r->provider);
12746         ndr->depth++;
12747         if (r->provider) {
12748                 ndr_print_string(ndr, "provider", r->provider);
12749         }
12750         ndr->depth--;
12751         ndr->depth--;
12752 }
12753
12754 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12755 {
12756         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12757 }
12758
12759 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12760 {
12761         if (ndr_flags & NDR_SCALARS) {
12762                 NDR_CHECK(ndr_push_align(ndr, 8));
12763                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12764                 {
12765                         uint32_t _flags_save_string = ndr->flags;
12766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12767                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12768                         ndr->flags = _flags_save_string;
12769                 }
12770                 {
12771                         uint32_t _flags_save_string = ndr->flags;
12772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12773                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12774                         ndr->flags = _flags_save_string;
12775                 }
12776                 {
12777                         uint32_t _flags_save_string = ndr->flags;
12778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12779                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12780                         ndr->flags = _flags_save_string;
12781                 }
12782                 {
12783                         uint32_t _flags_save_string = ndr->flags;
12784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12785                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12792                         ndr->flags = _flags_save_string;
12793                 }
12794                 {
12795                         uint32_t _flags_save_string = ndr->flags;
12796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12797                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12798                         ndr->flags = _flags_save_string;
12799                 }
12800                 {
12801                         uint32_t _flags_save_string = ndr->flags;
12802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12803                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12804                         ndr->flags = _flags_save_string;
12805                 }
12806                 {
12807                         uint32_t _flags_save_string = ndr->flags;
12808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12809                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12810                         ndr->flags = _flags_save_string;
12811                 }
12812                 {
12813                         uint32_t _flags_save_string_array = ndr->flags;
12814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12815                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12816                         ndr->flags = _flags_save_string_array;
12817                 }
12818                 {
12819                         uint32_t _flags_save_string_array = ndr->flags;
12820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12821                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12822                         ndr->flags = _flags_save_string_array;
12823                 }
12824                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12825                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12826                 {
12827                         uint32_t _flags_save_string = ndr->flags;
12828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12829                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12830                         ndr->flags = _flags_save_string;
12831                 }
12832                 {
12833                         uint32_t _flags_save_string = ndr->flags;
12834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12835                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12836                         ndr->flags = _flags_save_string;
12837                 }
12838                 {
12839                         uint32_t _flags_save_string = ndr->flags;
12840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12841                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12842                         ndr->flags = _flags_save_string;
12843                 }
12844                 {
12845                         uint32_t _flags_save_string = ndr->flags;
12846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12847                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12848                         ndr->flags = _flags_save_string;
12849                 }
12850                 {
12851                         uint32_t _flags_save_string = ndr->flags;
12852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12853                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12854                         ndr->flags = _flags_save_string;
12855                 }
12856                 {
12857                         uint32_t _flags_save_string = ndr->flags;
12858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12859                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12860                         ndr->flags = _flags_save_string;
12861                 }
12862                 {
12863                         uint32_t _flags_save_string_array = ndr->flags;
12864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12865                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12866                         ndr->flags = _flags_save_string_array;
12867                 }
12868                 {
12869                         uint32_t _flags_save_string = ndr->flags;
12870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12871                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12872                         ndr->flags = _flags_save_string;
12873                 }
12874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12875                 {
12876                         uint32_t _flags_save_string_array = ndr->flags;
12877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12878                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12879                         ndr->flags = _flags_save_string_array;
12880                 }
12881                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12882                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12883         }
12884         if (ndr_flags & NDR_BUFFERS) {
12885                 {
12886                         uint32_t _flags_save_string = ndr->flags;
12887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12888                         if (r->driver_name) {
12889                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12890                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12891                         }
12892                         ndr->flags = _flags_save_string;
12893                 }
12894                 {
12895                         uint32_t _flags_save_string = ndr->flags;
12896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12897                         if (r->architecture) {
12898                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12899                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12900                         }
12901                         ndr->flags = _flags_save_string;
12902                 }
12903                 {
12904                         uint32_t _flags_save_string = ndr->flags;
12905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12906                         if (r->driver_path) {
12907                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12908                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12909                         }
12910                         ndr->flags = _flags_save_string;
12911                 }
12912                 {
12913                         uint32_t _flags_save_string = ndr->flags;
12914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12915                         if (r->data_file) {
12916                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12917                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12918                         }
12919                         ndr->flags = _flags_save_string;
12920                 }
12921                 {
12922                         uint32_t _flags_save_string = ndr->flags;
12923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12924                         if (r->config_file) {
12925                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12926                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12927                         }
12928                         ndr->flags = _flags_save_string;
12929                 }
12930                 {
12931                         uint32_t _flags_save_string = ndr->flags;
12932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12933                         if (r->help_file) {
12934                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12935                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12936                         }
12937                         ndr->flags = _flags_save_string;
12938                 }
12939                 {
12940                         uint32_t _flags_save_string = ndr->flags;
12941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12942                         if (r->monitor_name) {
12943                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12944                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12945                         }
12946                         ndr->flags = _flags_save_string;
12947                 }
12948                 {
12949                         uint32_t _flags_save_string = ndr->flags;
12950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12951                         if (r->default_datatype) {
12952                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12953                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12954                         }
12955                         ndr->flags = _flags_save_string;
12956                 }
12957                 {
12958                         uint32_t _flags_save_string_array = ndr->flags;
12959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12960                         if (r->dependent_files) {
12961                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12962                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12963                         }
12964                         ndr->flags = _flags_save_string_array;
12965                 }
12966                 {
12967                         uint32_t _flags_save_string_array = ndr->flags;
12968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12969                         if (r->previous_names) {
12970                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12971                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12972                         }
12973                         ndr->flags = _flags_save_string_array;
12974                 }
12975                 {
12976                         uint32_t _flags_save_string = ndr->flags;
12977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12978                         if (r->manufacturer_name) {
12979                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12980                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12981                         }
12982                         ndr->flags = _flags_save_string;
12983                 }
12984                 {
12985                         uint32_t _flags_save_string = ndr->flags;
12986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12987                         if (r->manufacturer_url) {
12988                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12989                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12990                         }
12991                         ndr->flags = _flags_save_string;
12992                 }
12993                 {
12994                         uint32_t _flags_save_string = ndr->flags;
12995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12996                         if (r->hardware_id) {
12997                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12998                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12999                         }
13000                         ndr->flags = _flags_save_string;
13001                 }
13002                 {
13003                         uint32_t _flags_save_string = ndr->flags;
13004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13005                         if (r->provider) {
13006                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
13007                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13008                         }
13009                         ndr->flags = _flags_save_string;
13010                 }
13011                 {
13012                         uint32_t _flags_save_string = ndr->flags;
13013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13014                         if (r->print_processor) {
13015                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
13016                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13017                         }
13018                         ndr->flags = _flags_save_string;
13019                 }
13020                 {
13021                         uint32_t _flags_save_string = ndr->flags;
13022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13023                         if (r->vendor_setup) {
13024                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
13025                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13026                         }
13027                         ndr->flags = _flags_save_string;
13028                 }
13029                 {
13030                         uint32_t _flags_save_string_array = ndr->flags;
13031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13032                         if (r->color_profiles) {
13033                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
13034                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13035                         }
13036                         ndr->flags = _flags_save_string_array;
13037                 }
13038                 {
13039                         uint32_t _flags_save_string = ndr->flags;
13040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13041                         if (r->inf_path) {
13042                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
13043                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13044                         }
13045                         ndr->flags = _flags_save_string;
13046                 }
13047                 {
13048                         uint32_t _flags_save_string_array = ndr->flags;
13049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13050                         if (r->core_driver_dependencies) {
13051                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
13052                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13053                         }
13054                         ndr->flags = _flags_save_string_array;
13055                 }
13056         }
13057         return NDR_ERR_SUCCESS;
13058 }
13059
13060 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13061 {
13062         uint32_t _ptr_driver_name;
13063         TALLOC_CTX *_mem_save_driver_name_0;
13064         uint32_t _ptr_architecture;
13065         TALLOC_CTX *_mem_save_architecture_0;
13066         uint32_t _ptr_driver_path;
13067         TALLOC_CTX *_mem_save_driver_path_0;
13068         uint32_t _ptr_data_file;
13069         TALLOC_CTX *_mem_save_data_file_0;
13070         uint32_t _ptr_config_file;
13071         TALLOC_CTX *_mem_save_config_file_0;
13072         uint32_t _ptr_help_file;
13073         TALLOC_CTX *_mem_save_help_file_0;
13074         uint32_t _ptr_monitor_name;
13075         TALLOC_CTX *_mem_save_monitor_name_0;
13076         uint32_t _ptr_default_datatype;
13077         TALLOC_CTX *_mem_save_default_datatype_0;
13078         uint32_t _ptr_dependent_files;
13079         TALLOC_CTX *_mem_save_dependent_files_0;
13080         uint32_t _ptr_previous_names;
13081         TALLOC_CTX *_mem_save_previous_names_0;
13082         uint32_t _ptr_manufacturer_name;
13083         TALLOC_CTX *_mem_save_manufacturer_name_0;
13084         uint32_t _ptr_manufacturer_url;
13085         TALLOC_CTX *_mem_save_manufacturer_url_0;
13086         uint32_t _ptr_hardware_id;
13087         TALLOC_CTX *_mem_save_hardware_id_0;
13088         uint32_t _ptr_provider;
13089         TALLOC_CTX *_mem_save_provider_0;
13090         uint32_t _ptr_print_processor;
13091         TALLOC_CTX *_mem_save_print_processor_0;
13092         uint32_t _ptr_vendor_setup;
13093         TALLOC_CTX *_mem_save_vendor_setup_0;
13094         uint32_t _ptr_color_profiles;
13095         TALLOC_CTX *_mem_save_color_profiles_0;
13096         uint32_t _ptr_inf_path;
13097         TALLOC_CTX *_mem_save_inf_path_0;
13098         uint32_t _ptr_core_driver_dependencies;
13099         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13100         if (ndr_flags & NDR_SCALARS) {
13101                 NDR_CHECK(ndr_pull_align(ndr, 8));
13102                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13103                 {
13104                         uint32_t _flags_save_string = ndr->flags;
13105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13106                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13107                         if (_ptr_driver_name) {
13108                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13109                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13110                         } else {
13111                                 r->driver_name = NULL;
13112                         }
13113                         ndr->flags = _flags_save_string;
13114                 }
13115                 {
13116                         uint32_t _flags_save_string = ndr->flags;
13117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13119                         if (_ptr_architecture) {
13120                                 NDR_PULL_ALLOC(ndr, r->architecture);
13121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13122                         } else {
13123                                 r->architecture = NULL;
13124                         }
13125                         ndr->flags = _flags_save_string;
13126                 }
13127                 {
13128                         uint32_t _flags_save_string = ndr->flags;
13129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13131                         if (_ptr_driver_path) {
13132                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13133                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13134                         } else {
13135                                 r->driver_path = NULL;
13136                         }
13137                         ndr->flags = _flags_save_string;
13138                 }
13139                 {
13140                         uint32_t _flags_save_string = ndr->flags;
13141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13142                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13143                         if (_ptr_data_file) {
13144                                 NDR_PULL_ALLOC(ndr, r->data_file);
13145                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13146                         } else {
13147                                 r->data_file = NULL;
13148                         }
13149                         ndr->flags = _flags_save_string;
13150                 }
13151                 {
13152                         uint32_t _flags_save_string = ndr->flags;
13153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13155                         if (_ptr_config_file) {
13156                                 NDR_PULL_ALLOC(ndr, r->config_file);
13157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13158                         } else {
13159                                 r->config_file = NULL;
13160                         }
13161                         ndr->flags = _flags_save_string;
13162                 }
13163                 {
13164                         uint32_t _flags_save_string = ndr->flags;
13165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13166                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13167                         if (_ptr_help_file) {
13168                                 NDR_PULL_ALLOC(ndr, r->help_file);
13169                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13170                         } else {
13171                                 r->help_file = NULL;
13172                         }
13173                         ndr->flags = _flags_save_string;
13174                 }
13175                 {
13176                         uint32_t _flags_save_string = ndr->flags;
13177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13178                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13179                         if (_ptr_monitor_name) {
13180                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13181                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13182                         } else {
13183                                 r->monitor_name = NULL;
13184                         }
13185                         ndr->flags = _flags_save_string;
13186                 }
13187                 {
13188                         uint32_t _flags_save_string = ndr->flags;
13189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13190                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13191                         if (_ptr_default_datatype) {
13192                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13193                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13194                         } else {
13195                                 r->default_datatype = NULL;
13196                         }
13197                         ndr->flags = _flags_save_string;
13198                 }
13199                 {
13200                         uint32_t _flags_save_string_array = ndr->flags;
13201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13202                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13203                         if (_ptr_dependent_files) {
13204                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13205                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13206                         } else {
13207                                 r->dependent_files = NULL;
13208                         }
13209                         ndr->flags = _flags_save_string_array;
13210                 }
13211                 {
13212                         uint32_t _flags_save_string_array = ndr->flags;
13213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13215                         if (_ptr_previous_names) {
13216                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13218                         } else {
13219                                 r->previous_names = NULL;
13220                         }
13221                         ndr->flags = _flags_save_string_array;
13222                 }
13223                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13224                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
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_manufacturer_name));
13229                         if (_ptr_manufacturer_name) {
13230                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13232                         } else {
13233                                 r->manufacturer_name = NULL;
13234                         }
13235                         ndr->flags = _flags_save_string;
13236                 }
13237                 {
13238                         uint32_t _flags_save_string = ndr->flags;
13239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13241                         if (_ptr_manufacturer_url) {
13242                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13244                         } else {
13245                                 r->manufacturer_url = NULL;
13246                         }
13247                         ndr->flags = _flags_save_string;
13248                 }
13249                 {
13250                         uint32_t _flags_save_string = ndr->flags;
13251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13253                         if (_ptr_hardware_id) {
13254                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13256                         } else {
13257                                 r->hardware_id = NULL;
13258                         }
13259                         ndr->flags = _flags_save_string;
13260                 }
13261                 {
13262                         uint32_t _flags_save_string = ndr->flags;
13263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13264                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13265                         if (_ptr_provider) {
13266                                 NDR_PULL_ALLOC(ndr, r->provider);
13267                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13268                         } else {
13269                                 r->provider = NULL;
13270                         }
13271                         ndr->flags = _flags_save_string;
13272                 }
13273                 {
13274                         uint32_t _flags_save_string = ndr->flags;
13275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13276                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13277                         if (_ptr_print_processor) {
13278                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13279                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13280                         } else {
13281                                 r->print_processor = NULL;
13282                         }
13283                         ndr->flags = _flags_save_string;
13284                 }
13285                 {
13286                         uint32_t _flags_save_string = ndr->flags;
13287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13288                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13289                         if (_ptr_vendor_setup) {
13290                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13291                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13292                         } else {
13293                                 r->vendor_setup = NULL;
13294                         }
13295                         ndr->flags = _flags_save_string;
13296                 }
13297                 {
13298                         uint32_t _flags_save_string_array = ndr->flags;
13299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13300                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13301                         if (_ptr_color_profiles) {
13302                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13303                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13304                         } else {
13305                                 r->color_profiles = NULL;
13306                         }
13307                         ndr->flags = _flags_save_string_array;
13308                 }
13309                 {
13310                         uint32_t _flags_save_string = ndr->flags;
13311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13312                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13313                         if (_ptr_inf_path) {
13314                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13315                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13316                         } else {
13317                                 r->inf_path = NULL;
13318                         }
13319                         ndr->flags = _flags_save_string;
13320                 }
13321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13322                 {
13323                         uint32_t _flags_save_string_array = ndr->flags;
13324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13325                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13326                         if (_ptr_core_driver_dependencies) {
13327                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13328                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13329                         } else {
13330                                 r->core_driver_dependencies = NULL;
13331                         }
13332                         ndr->flags = _flags_save_string_array;
13333                 }
13334                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13335                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13336         }
13337         if (ndr_flags & NDR_BUFFERS) {
13338                 {
13339                         uint32_t _flags_save_string = ndr->flags;
13340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13341                         if (r->driver_name) {
13342                                 uint32_t _relative_save_offset;
13343                                 _relative_save_offset = ndr->offset;
13344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13345                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13346                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13349                                 ndr->offset = _relative_save_offset;
13350                         }
13351                         ndr->flags = _flags_save_string;
13352                 }
13353                 {
13354                         uint32_t _flags_save_string = ndr->flags;
13355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13356                         if (r->architecture) {
13357                                 uint32_t _relative_save_offset;
13358                                 _relative_save_offset = ndr->offset;
13359                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13360                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13361                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13362                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13363                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13364                                 ndr->offset = _relative_save_offset;
13365                         }
13366                         ndr->flags = _flags_save_string;
13367                 }
13368                 {
13369                         uint32_t _flags_save_string = ndr->flags;
13370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13371                         if (r->driver_path) {
13372                                 uint32_t _relative_save_offset;
13373                                 _relative_save_offset = ndr->offset;
13374                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13375                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13376                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13377                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13378                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13379                                 ndr->offset = _relative_save_offset;
13380                         }
13381                         ndr->flags = _flags_save_string;
13382                 }
13383                 {
13384                         uint32_t _flags_save_string = ndr->flags;
13385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13386                         if (r->data_file) {
13387                                 uint32_t _relative_save_offset;
13388                                 _relative_save_offset = ndr->offset;
13389                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13390                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13391                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13392                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13393                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13394                                 ndr->offset = _relative_save_offset;
13395                         }
13396                         ndr->flags = _flags_save_string;
13397                 }
13398                 {
13399                         uint32_t _flags_save_string = ndr->flags;
13400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13401                         if (r->config_file) {
13402                                 uint32_t _relative_save_offset;
13403                                 _relative_save_offset = ndr->offset;
13404                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13405                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13406                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13407                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13408                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13409                                 ndr->offset = _relative_save_offset;
13410                         }
13411                         ndr->flags = _flags_save_string;
13412                 }
13413                 {
13414                         uint32_t _flags_save_string = ndr->flags;
13415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13416                         if (r->help_file) {
13417                                 uint32_t _relative_save_offset;
13418                                 _relative_save_offset = ndr->offset;
13419                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13420                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13421                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13422                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13423                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13424                                 ndr->offset = _relative_save_offset;
13425                         }
13426                         ndr->flags = _flags_save_string;
13427                 }
13428                 {
13429                         uint32_t _flags_save_string = ndr->flags;
13430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13431                         if (r->monitor_name) {
13432                                 uint32_t _relative_save_offset;
13433                                 _relative_save_offset = ndr->offset;
13434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13435                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13436                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13439                                 ndr->offset = _relative_save_offset;
13440                         }
13441                         ndr->flags = _flags_save_string;
13442                 }
13443                 {
13444                         uint32_t _flags_save_string = ndr->flags;
13445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13446                         if (r->default_datatype) {
13447                                 uint32_t _relative_save_offset;
13448                                 _relative_save_offset = ndr->offset;
13449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13450                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13451                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13454                                 ndr->offset = _relative_save_offset;
13455                         }
13456                         ndr->flags = _flags_save_string;
13457                 }
13458                 {
13459                         uint32_t _flags_save_string_array = ndr->flags;
13460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13461                         if (r->dependent_files) {
13462                                 uint32_t _relative_save_offset;
13463                                 _relative_save_offset = ndr->offset;
13464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13465                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13466                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13467                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13469                                 ndr->offset = _relative_save_offset;
13470                         }
13471                         ndr->flags = _flags_save_string_array;
13472                 }
13473                 {
13474                         uint32_t _flags_save_string_array = ndr->flags;
13475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13476                         if (r->previous_names) {
13477                                 uint32_t _relative_save_offset;
13478                                 _relative_save_offset = ndr->offset;
13479                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13480                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13481                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13482                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13483                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13484                                 ndr->offset = _relative_save_offset;
13485                         }
13486                         ndr->flags = _flags_save_string_array;
13487                 }
13488                 {
13489                         uint32_t _flags_save_string = ndr->flags;
13490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13491                         if (r->manufacturer_name) {
13492                                 uint32_t _relative_save_offset;
13493                                 _relative_save_offset = ndr->offset;
13494                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13495                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13496                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13497                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13498                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13499                                 ndr->offset = _relative_save_offset;
13500                         }
13501                         ndr->flags = _flags_save_string;
13502                 }
13503                 {
13504                         uint32_t _flags_save_string = ndr->flags;
13505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13506                         if (r->manufacturer_url) {
13507                                 uint32_t _relative_save_offset;
13508                                 _relative_save_offset = ndr->offset;
13509                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13510                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13511                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13512                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13513                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13514                                 ndr->offset = _relative_save_offset;
13515                         }
13516                         ndr->flags = _flags_save_string;
13517                 }
13518                 {
13519                         uint32_t _flags_save_string = ndr->flags;
13520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13521                         if (r->hardware_id) {
13522                                 uint32_t _relative_save_offset;
13523                                 _relative_save_offset = ndr->offset;
13524                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13525                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13526                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13527                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13528                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13529                                 ndr->offset = _relative_save_offset;
13530                         }
13531                         ndr->flags = _flags_save_string;
13532                 }
13533                 {
13534                         uint32_t _flags_save_string = ndr->flags;
13535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13536                         if (r->provider) {
13537                                 uint32_t _relative_save_offset;
13538                                 _relative_save_offset = ndr->offset;
13539                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13540                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13541                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13542                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13543                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13544                                 ndr->offset = _relative_save_offset;
13545                         }
13546                         ndr->flags = _flags_save_string;
13547                 }
13548                 {
13549                         uint32_t _flags_save_string = ndr->flags;
13550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13551                         if (r->print_processor) {
13552                                 uint32_t _relative_save_offset;
13553                                 _relative_save_offset = ndr->offset;
13554                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13555                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13556                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13557                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13558                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13559                                 ndr->offset = _relative_save_offset;
13560                         }
13561                         ndr->flags = _flags_save_string;
13562                 }
13563                 {
13564                         uint32_t _flags_save_string = ndr->flags;
13565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13566                         if (r->vendor_setup) {
13567                                 uint32_t _relative_save_offset;
13568                                 _relative_save_offset = ndr->offset;
13569                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13570                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13571                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13572                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13573                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13574                                 ndr->offset = _relative_save_offset;
13575                         }
13576                         ndr->flags = _flags_save_string;
13577                 }
13578                 {
13579                         uint32_t _flags_save_string_array = ndr->flags;
13580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13581                         if (r->color_profiles) {
13582                                 uint32_t _relative_save_offset;
13583                                 _relative_save_offset = ndr->offset;
13584                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13585                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13586                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13587                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13588                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13589                                 ndr->offset = _relative_save_offset;
13590                         }
13591                         ndr->flags = _flags_save_string_array;
13592                 }
13593                 {
13594                         uint32_t _flags_save_string = ndr->flags;
13595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13596                         if (r->inf_path) {
13597                                 uint32_t _relative_save_offset;
13598                                 _relative_save_offset = ndr->offset;
13599                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13600                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13601                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13602                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13603                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13604                                 ndr->offset = _relative_save_offset;
13605                         }
13606                         ndr->flags = _flags_save_string;
13607                 }
13608                 {
13609                         uint32_t _flags_save_string_array = ndr->flags;
13610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13611                         if (r->core_driver_dependencies) {
13612                                 uint32_t _relative_save_offset;
13613                                 _relative_save_offset = ndr->offset;
13614                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13615                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13616                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13617                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13618                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13619                                 ndr->offset = _relative_save_offset;
13620                         }
13621                         ndr->flags = _flags_save_string_array;
13622                 }
13623         }
13624         return NDR_ERR_SUCCESS;
13625 }
13626
13627 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13628 {
13629         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13630         ndr->depth++;
13631         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13632         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13633         ndr->depth++;
13634         if (r->driver_name) {
13635                 ndr_print_string(ndr, "driver_name", r->driver_name);
13636         }
13637         ndr->depth--;
13638         ndr_print_ptr(ndr, "architecture", r->architecture);
13639         ndr->depth++;
13640         if (r->architecture) {
13641                 ndr_print_string(ndr, "architecture", r->architecture);
13642         }
13643         ndr->depth--;
13644         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13645         ndr->depth++;
13646         if (r->driver_path) {
13647                 ndr_print_string(ndr, "driver_path", r->driver_path);
13648         }
13649         ndr->depth--;
13650         ndr_print_ptr(ndr, "data_file", r->data_file);
13651         ndr->depth++;
13652         if (r->data_file) {
13653                 ndr_print_string(ndr, "data_file", r->data_file);
13654         }
13655         ndr->depth--;
13656         ndr_print_ptr(ndr, "config_file", r->config_file);
13657         ndr->depth++;
13658         if (r->config_file) {
13659                 ndr_print_string(ndr, "config_file", r->config_file);
13660         }
13661         ndr->depth--;
13662         ndr_print_ptr(ndr, "help_file", r->help_file);
13663         ndr->depth++;
13664         if (r->help_file) {
13665                 ndr_print_string(ndr, "help_file", r->help_file);
13666         }
13667         ndr->depth--;
13668         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13669         ndr->depth++;
13670         if (r->monitor_name) {
13671                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13672         }
13673         ndr->depth--;
13674         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13675         ndr->depth++;
13676         if (r->default_datatype) {
13677                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13678         }
13679         ndr->depth--;
13680         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13681         ndr->depth++;
13682         if (r->dependent_files) {
13683                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13684         }
13685         ndr->depth--;
13686         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13687         ndr->depth++;
13688         if (r->previous_names) {
13689                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13690         }
13691         ndr->depth--;
13692         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13693         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13694         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13695         ndr->depth++;
13696         if (r->manufacturer_name) {
13697                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13698         }
13699         ndr->depth--;
13700         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13701         ndr->depth++;
13702         if (r->manufacturer_url) {
13703                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13704         }
13705         ndr->depth--;
13706         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13707         ndr->depth++;
13708         if (r->hardware_id) {
13709                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13710         }
13711         ndr->depth--;
13712         ndr_print_ptr(ndr, "provider", r->provider);
13713         ndr->depth++;
13714         if (r->provider) {
13715                 ndr_print_string(ndr, "provider", r->provider);
13716         }
13717         ndr->depth--;
13718         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13719         ndr->depth++;
13720         if (r->print_processor) {
13721                 ndr_print_string(ndr, "print_processor", r->print_processor);
13722         }
13723         ndr->depth--;
13724         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13725         ndr->depth++;
13726         if (r->vendor_setup) {
13727                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13728         }
13729         ndr->depth--;
13730         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13731         ndr->depth++;
13732         if (r->color_profiles) {
13733                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13734         }
13735         ndr->depth--;
13736         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13737         ndr->depth++;
13738         if (r->inf_path) {
13739                 ndr_print_string(ndr, "inf_path", r->inf_path);
13740         }
13741         ndr->depth--;
13742         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13743         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13744         ndr->depth++;
13745         if (r->core_driver_dependencies) {
13746                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13747         }
13748         ndr->depth--;
13749         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13750         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13751         ndr->depth--;
13752 }
13753
13754 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13755 {
13756         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13757 }
13758
13759 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13760 {
13761         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
13762         return NDR_ERR_SUCCESS;
13763 }
13764
13765 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13766 {
13767         uint32_t v;
13768         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
13769         *r = v;
13770         return NDR_ERR_SUCCESS;
13771 }
13772
13773 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13774 {
13775         const char *val = NULL;
13776
13777         switch (r) {
13778                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13779                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13780                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13781                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13782                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13783         }
13784         ndr_print_enum(ndr, name, "ENUM", val, r);
13785 }
13786
13787 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13788 {
13789         if (ndr_flags & NDR_SCALARS) {
13790                 NDR_CHECK(ndr_push_align(ndr, 5));
13791                 {
13792                         uint32_t _flags_save_string = ndr->flags;
13793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13794                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13795                         ndr->flags = _flags_save_string;
13796                 }
13797                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13799         }
13800         if (ndr_flags & NDR_BUFFERS) {
13801                 {
13802                         uint32_t _flags_save_string = ndr->flags;
13803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13804                         if (r->file_name) {
13805                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13806                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13807                         }
13808                         ndr->flags = _flags_save_string;
13809                 }
13810         }
13811         return NDR_ERR_SUCCESS;
13812 }
13813
13814 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13815 {
13816         uint32_t _ptr_file_name;
13817         TALLOC_CTX *_mem_save_file_name_0;
13818         if (ndr_flags & NDR_SCALARS) {
13819                 NDR_CHECK(ndr_pull_align(ndr, 5));
13820                 {
13821                         uint32_t _flags_save_string = ndr->flags;
13822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13823                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13824                         if (_ptr_file_name) {
13825                                 NDR_PULL_ALLOC(ndr, r->file_name);
13826                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13827                         } else {
13828                                 r->file_name = NULL;
13829                         }
13830                         ndr->flags = _flags_save_string;
13831                 }
13832                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13834         }
13835         if (ndr_flags & NDR_BUFFERS) {
13836                 {
13837                         uint32_t _flags_save_string = ndr->flags;
13838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13839                         if (r->file_name) {
13840                                 uint32_t _relative_save_offset;
13841                                 _relative_save_offset = ndr->offset;
13842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13843                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13844                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13847                                 ndr->offset = _relative_save_offset;
13848                         }
13849                         ndr->flags = _flags_save_string;
13850                 }
13851         }
13852         return NDR_ERR_SUCCESS;
13853 }
13854
13855 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13856 {
13857         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13858         ndr->depth++;
13859         ndr_print_ptr(ndr, "file_name", r->file_name);
13860         ndr->depth++;
13861         if (r->file_name) {
13862                 ndr_print_string(ndr, "file_name", r->file_name);
13863         }
13864         ndr->depth--;
13865         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13866         ndr_print_uint32(ndr, "file_version", r->file_version);
13867         ndr->depth--;
13868 }
13869
13870 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13871 {
13872         uint32_t cntr_file_info_1;
13873         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13874         ndr->depth++;
13875         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13876         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13877         ndr->depth++;
13878         if (r->driver_name) {
13879                 ndr_print_string(ndr, "driver_name", r->driver_name);
13880         }
13881         ndr->depth--;
13882         ndr_print_ptr(ndr, "architecture", r->architecture);
13883         ndr->depth++;
13884         if (r->architecture) {
13885                 ndr_print_string(ndr, "architecture", r->architecture);
13886         }
13887         ndr->depth--;
13888         ndr_print_ptr(ndr, "file_info", r->file_info);
13889         ndr->depth++;
13890         if (r->file_info) {
13891                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13892                 ndr->depth++;
13893                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13894                         char *idx_1=NULL;
13895                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13896                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13897                                 free(idx_1);
13898                         }
13899                 }
13900                 ndr->depth--;
13901         }
13902         ndr->depth--;
13903         ndr_print_uint32(ndr, "file_count", r->file_count);
13904         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13905         ndr->depth++;
13906         if (r->monitor_name) {
13907                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13908         }
13909         ndr->depth--;
13910         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13911         ndr->depth++;
13912         if (r->default_datatype) {
13913                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13914         }
13915         ndr->depth--;
13916         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13917         ndr->depth++;
13918         if (r->previous_names) {
13919                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13920         }
13921         ndr->depth--;
13922         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13923         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13924         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13925         ndr->depth++;
13926         if (r->manufacturer_name) {
13927                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13928         }
13929         ndr->depth--;
13930         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13931         ndr->depth++;
13932         if (r->manufacturer_url) {
13933                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13934         }
13935         ndr->depth--;
13936         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13937         ndr->depth++;
13938         if (r->hardware_id) {
13939                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13940         }
13941         ndr->depth--;
13942         ndr_print_ptr(ndr, "provider", r->provider);
13943         ndr->depth++;
13944         if (r->provider) {
13945                 ndr_print_string(ndr, "provider", r->provider);
13946         }
13947         ndr->depth--;
13948         ndr->depth--;
13949 }
13950
13951 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13952 {
13953         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13954 }
13955
13956 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13957 {
13958         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13959         if (ndr_flags & NDR_SCALARS) {
13960                 int level = ndr_push_get_switch_value(ndr, r);
13961                 NDR_CHECK(ndr_push_union_align(ndr, 8));
13962                 switch (level) {
13963                         case 1: {
13964                                 NDR_CHECK(ndr_push_align(ndr, 5));
13965                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13966                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13967                         break; }
13968
13969                         case 2: {
13970                                 NDR_CHECK(ndr_push_align(ndr, 5));
13971                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13972                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13973                         break; }
13974
13975                         case 3: {
13976                                 NDR_CHECK(ndr_push_align(ndr, 5));
13977                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13978                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13979                         break; }
13980
13981                         case 4: {
13982                                 NDR_CHECK(ndr_push_align(ndr, 5));
13983                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13984                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13985                         break; }
13986
13987                         case 5: {
13988                                 NDR_CHECK(ndr_push_align(ndr, 5));
13989                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13990                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13991                         break; }
13992
13993                         case 6: {
13994                                 NDR_CHECK(ndr_push_align(ndr, 8));
13995                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13996                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13997                         break; }
13998
13999                         case 8: {
14000                                 NDR_CHECK(ndr_push_align(ndr, 8));
14001                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14002                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14003                         break; }
14004
14005                         case 101: {
14006                                 NDR_CHECK(ndr_push_align(ndr, 8));
14007                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14008                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14009                         break; }
14010
14011                         default: {
14012                         break; }
14013
14014                 }
14015         }
14016         if (ndr_flags & NDR_BUFFERS) {
14017                 int level = ndr_push_get_switch_value(ndr, r);
14018                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14019                 switch (level) {
14020                         case 1:
14021                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14022                         break;
14023
14024                         case 2:
14025                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14026                         break;
14027
14028                         case 3:
14029                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14030                         break;
14031
14032                         case 4:
14033                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14034                         break;
14035
14036                         case 5:
14037                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14038                         break;
14039
14040                         case 6:
14041                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14042                         break;
14043
14044                         case 8:
14045                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14046                         break;
14047
14048                         case 101:
14049                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14050                         break;
14051
14052                         default:
14053                         break;
14054
14055                 }
14056         }
14057         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14058         return NDR_ERR_SUCCESS;
14059 }
14060
14061 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14062 {
14063         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14064         int level;
14065         level = ndr_pull_get_switch_value(ndr, r);
14066         if (ndr_flags & NDR_SCALARS) {
14067                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
14068                 switch (level) {
14069                         case 1: {
14070                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14071                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14072                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14073                         break; }
14074
14075                         case 2: {
14076                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14077                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14078                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14079                         break; }
14080
14081                         case 3: {
14082                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14083                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14084                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14085                         break; }
14086
14087                         case 4: {
14088                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14089                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14090                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14091                         break; }
14092
14093                         case 5: {
14094                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14095                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14096                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14097                         break; }
14098
14099                         case 6: {
14100                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14101                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14102                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14103                         break; }
14104
14105                         case 8: {
14106                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14107                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14108                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14109                         break; }
14110
14111                         case 101: {
14112                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14113                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14114                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14115                         break; }
14116
14117                         default: {
14118                         break; }
14119
14120                 }
14121         }
14122         if (ndr_flags & NDR_BUFFERS) {
14123                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14124                 switch (level) {
14125                         case 1:
14126                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14127                         break;
14128
14129                         case 2:
14130                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14131                         break;
14132
14133                         case 3:
14134                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14135                         break;
14136
14137                         case 4:
14138                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14139                         break;
14140
14141                         case 5:
14142                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14143                         break;
14144
14145                         case 6:
14146                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14147                         break;
14148
14149                         case 8:
14150                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14151                         break;
14152
14153                         case 101:
14154                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14155                         break;
14156
14157                         default:
14158                         break;
14159
14160                 }
14161         }
14162         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14163         return NDR_ERR_SUCCESS;
14164 }
14165
14166 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14167 {
14168         int level;
14169         level = ndr_print_get_switch_value(ndr, r);
14170         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14171         switch (level) {
14172                 case 1:
14173                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14174                 break;
14175
14176                 case 2:
14177                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14178                 break;
14179
14180                 case 3:
14181                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14182                 break;
14183
14184                 case 4:
14185                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14186                 break;
14187
14188                 case 5:
14189                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14190                 break;
14191
14192                 case 6:
14193                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14194                 break;
14195
14196                 case 8:
14197                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14198                 break;
14199
14200                 case 101:
14201                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14202                 break;
14203
14204                 default:
14205                 break;
14206
14207         }
14208 }
14209
14210 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14211 {
14212         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14213 }
14214
14215 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14216 {
14217         if (ndr_flags & NDR_SCALARS) {
14218                 NDR_CHECK(ndr_push_align(ndr, 4));
14219                 {
14220                         uint32_t _flags_save_string = ndr->flags;
14221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14222                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14223                         ndr->flags = _flags_save_string;
14224                 }
14225         }
14226         if (ndr_flags & NDR_BUFFERS) {
14227         }
14228         return NDR_ERR_SUCCESS;
14229 }
14230
14231 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14232 {
14233         if (ndr_flags & NDR_SCALARS) {
14234                 NDR_CHECK(ndr_pull_align(ndr, 4));
14235                 {
14236                         uint32_t _flags_save_string = ndr->flags;
14237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14238                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14239                         ndr->flags = _flags_save_string;
14240                 }
14241         }
14242         if (ndr_flags & NDR_BUFFERS) {
14243         }
14244         return NDR_ERR_SUCCESS;
14245 }
14246
14247 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14248 {
14249         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14250         ndr->depth++;
14251         ndr_print_string(ndr, "directory_name", r->directory_name);
14252         ndr->depth--;
14253 }
14254
14255 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14256 {
14257         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14258 }
14259
14260 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14261 {
14262         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14263         if (ndr_flags & NDR_SCALARS) {
14264                 int level = ndr_push_get_switch_value(ndr, r);
14265                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14266                 switch (level) {
14267                         case 1: {
14268                                 NDR_CHECK(ndr_push_align(ndr, 4));
14269                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14270                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14271                         break; }
14272
14273                         default: {
14274                                 NDR_CHECK(ndr_push_align(ndr, 4));
14275                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14276                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14277                         break; }
14278
14279                 }
14280         }
14281         if (ndr_flags & NDR_BUFFERS) {
14282                 int level = ndr_push_get_switch_value(ndr, r);
14283                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14284                 switch (level) {
14285                         case 1:
14286                         break;
14287
14288                         default:
14289                         break;
14290
14291                 }
14292         }
14293         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14294         return NDR_ERR_SUCCESS;
14295 }
14296
14297 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14298 {
14299         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14300         int level;
14301         level = ndr_pull_get_switch_value(ndr, r);
14302         if (ndr_flags & NDR_SCALARS) {
14303                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14304                 switch (level) {
14305                         case 1: {
14306                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14307                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14308                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14309                         break; }
14310
14311                         default: {
14312                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14313                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14314                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14315                         break; }
14316
14317                 }
14318         }
14319         if (ndr_flags & NDR_BUFFERS) {
14320                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14321                 switch (level) {
14322                         case 1:
14323                         break;
14324
14325                         default:
14326                         break;
14327
14328                 }
14329         }
14330         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14331         return NDR_ERR_SUCCESS;
14332 }
14333
14334 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
14335 {
14336         int level;
14337         level = ndr_print_get_switch_value(ndr, r);
14338         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
14339         switch (level) {
14340                 case 1:
14341                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14342                 break;
14343
14344                 default:
14345                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14346                 break;
14347
14348         }
14349 }
14350
14351 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14352 {
14353         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
14354 }
14355
14356 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
14357 {
14358         if (ndr_flags & NDR_SCALARS) {
14359                 NDR_CHECK(ndr_push_align(ndr, 5));
14360                 {
14361                         uint32_t _flags_save_string = ndr->flags;
14362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14363                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
14364                         ndr->flags = _flags_save_string;
14365                 }
14366         }
14367         if (ndr_flags & NDR_BUFFERS) {
14368                 {
14369                         uint32_t _flags_save_string = ndr->flags;
14370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14371                         if (r->print_processor_name) {
14372                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
14373                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
14374                         }
14375                         ndr->flags = _flags_save_string;
14376                 }
14377         }
14378         return NDR_ERR_SUCCESS;
14379 }
14380
14381 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
14382 {
14383         uint32_t _ptr_print_processor_name;
14384         TALLOC_CTX *_mem_save_print_processor_name_0;
14385         if (ndr_flags & NDR_SCALARS) {
14386                 NDR_CHECK(ndr_pull_align(ndr, 5));
14387                 {
14388                         uint32_t _flags_save_string = ndr->flags;
14389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
14391                         if (_ptr_print_processor_name) {
14392                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
14393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
14394                         } else {
14395                                 r->print_processor_name = NULL;
14396                         }
14397                         ndr->flags = _flags_save_string;
14398                 }
14399         }
14400         if (ndr_flags & NDR_BUFFERS) {
14401                 {
14402                         uint32_t _flags_save_string = ndr->flags;
14403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14404                         if (r->print_processor_name) {
14405                                 uint32_t _relative_save_offset;
14406                                 _relative_save_offset = ndr->offset;
14407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
14408                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14409                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
14410                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
14411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
14412                                 ndr->offset = _relative_save_offset;
14413                         }
14414                         ndr->flags = _flags_save_string;
14415                 }
14416         }
14417         return NDR_ERR_SUCCESS;
14418 }
14419
14420 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
14421 {
14422         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
14423         ndr->depth++;
14424         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
14425         ndr->depth++;
14426         if (r->print_processor_name) {
14427                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
14428         }
14429         ndr->depth--;
14430         ndr->depth--;
14431 }
14432
14433 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14434 {
14435         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
14436 }
14437
14438 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
14439 {
14440         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14441         if (ndr_flags & NDR_SCALARS) {
14442                 int level = ndr_push_get_switch_value(ndr, r);
14443                 NDR_CHECK(ndr_push_union_align(ndr, 5));
14444                 switch (level) {
14445                         case 1: {
14446                                 NDR_CHECK(ndr_push_align(ndr, 5));
14447                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14448                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14449                         break; }
14450
14451                         default: {
14452                         break; }
14453
14454                 }
14455         }
14456         if (ndr_flags & NDR_BUFFERS) {
14457                 int level = ndr_push_get_switch_value(ndr, r);
14458                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14459                 switch (level) {
14460                         case 1:
14461                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14462                         break;
14463
14464                         default:
14465                         break;
14466
14467                 }
14468         }
14469         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14470         return NDR_ERR_SUCCESS;
14471 }
14472
14473 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
14474 {
14475         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14476         int level;
14477         level = ndr_pull_get_switch_value(ndr, r);
14478         if (ndr_flags & NDR_SCALARS) {
14479                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14480                 switch (level) {
14481                         case 1: {
14482                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14483                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14484                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14485                         break; }
14486
14487                         default: {
14488                         break; }
14489
14490                 }
14491         }
14492         if (ndr_flags & NDR_BUFFERS) {
14493                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14494                 switch (level) {
14495                         case 1:
14496                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14497                         break;
14498
14499                         default:
14500                         break;
14501
14502                 }
14503         }
14504         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14505         return NDR_ERR_SUCCESS;
14506 }
14507
14508 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14509 {
14510         int level;
14511         level = ndr_print_get_switch_value(ndr, r);
14512         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14513         switch (level) {
14514                 case 1:
14515                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14516                 break;
14517
14518                 default:
14519                 break;
14520
14521         }
14522 }
14523
14524 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14525 {
14526         if (ndr_flags & NDR_SCALARS) {
14527                 NDR_CHECK(ndr_push_align(ndr, 4));
14528                 {
14529                         uint32_t _flags_save_string = ndr->flags;
14530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14531                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14532                         ndr->flags = _flags_save_string;
14533                 }
14534         }
14535         if (ndr_flags & NDR_BUFFERS) {
14536         }
14537         return NDR_ERR_SUCCESS;
14538 }
14539
14540 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14541 {
14542         if (ndr_flags & NDR_SCALARS) {
14543                 NDR_CHECK(ndr_pull_align(ndr, 4));
14544                 {
14545                         uint32_t _flags_save_string = ndr->flags;
14546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14547                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14548                         ndr->flags = _flags_save_string;
14549                 }
14550         }
14551         if (ndr_flags & NDR_BUFFERS) {
14552         }
14553         return NDR_ERR_SUCCESS;
14554 }
14555
14556 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14557 {
14558         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14559         ndr->depth++;
14560         ndr_print_string(ndr, "directory_name", r->directory_name);
14561         ndr->depth--;
14562 }
14563
14564 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14565 {
14566         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14567 }
14568
14569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14570 {
14571         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14572         if (ndr_flags & NDR_SCALARS) {
14573                 int level = ndr_push_get_switch_value(ndr, r);
14574                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14575                 switch (level) {
14576                         case 1: {
14577                                 NDR_CHECK(ndr_push_align(ndr, 4));
14578                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14579                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14580                         break; }
14581
14582                         default: {
14583                                 NDR_CHECK(ndr_push_align(ndr, 4));
14584                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14585                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14586                         break; }
14587
14588                 }
14589         }
14590         if (ndr_flags & NDR_BUFFERS) {
14591                 int level = ndr_push_get_switch_value(ndr, r);
14592                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14593                 switch (level) {
14594                         case 1:
14595                         break;
14596
14597                         default:
14598                         break;
14599
14600                 }
14601         }
14602         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14603         return NDR_ERR_SUCCESS;
14604 }
14605
14606 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14607 {
14608         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14609         int level;
14610         level = ndr_pull_get_switch_value(ndr, r);
14611         if (ndr_flags & NDR_SCALARS) {
14612                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14613                 switch (level) {
14614                         case 1: {
14615                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14616                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14617                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14618                         break; }
14619
14620                         default: {
14621                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14622                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14623                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14624                         break; }
14625
14626                 }
14627         }
14628         if (ndr_flags & NDR_BUFFERS) {
14629                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14630                 switch (level) {
14631                         case 1:
14632                         break;
14633
14634                         default:
14635                         break;
14636
14637                 }
14638         }
14639         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14640         return NDR_ERR_SUCCESS;
14641 }
14642
14643 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14644 {
14645         int level;
14646         level = ndr_print_get_switch_value(ndr, r);
14647         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14648         switch (level) {
14649                 case 1:
14650                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14651                 break;
14652
14653                 default:
14654                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14655                 break;
14656
14657         }
14658 }
14659
14660 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14661 {
14662         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14663 }
14664
14665 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14666 {
14667         if (ndr_flags & NDR_SCALARS) {
14668                 NDR_CHECK(ndr_push_align(ndr, 5));
14669                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14672         }
14673         if (ndr_flags & NDR_BUFFERS) {
14674                 if (r->document_name) {
14675                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14676                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14677                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14678                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14679                 }
14680                 if (r->output_file) {
14681                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14682                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14683                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14684                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14685                 }
14686                 if (r->datatype) {
14687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14690                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14691                 }
14692         }
14693         return NDR_ERR_SUCCESS;
14694 }
14695
14696 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14697 {
14698         uint32_t _ptr_document_name;
14699         TALLOC_CTX *_mem_save_document_name_0;
14700         uint32_t _ptr_output_file;
14701         TALLOC_CTX *_mem_save_output_file_0;
14702         uint32_t _ptr_datatype;
14703         TALLOC_CTX *_mem_save_datatype_0;
14704         if (ndr_flags & NDR_SCALARS) {
14705                 NDR_CHECK(ndr_pull_align(ndr, 5));
14706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14707                 if (_ptr_document_name) {
14708                         NDR_PULL_ALLOC(ndr, r->document_name);
14709                 } else {
14710                         r->document_name = NULL;
14711                 }
14712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14713                 if (_ptr_output_file) {
14714                         NDR_PULL_ALLOC(ndr, r->output_file);
14715                 } else {
14716                         r->output_file = NULL;
14717                 }
14718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14719                 if (_ptr_datatype) {
14720                         NDR_PULL_ALLOC(ndr, r->datatype);
14721                 } else {
14722                         r->datatype = NULL;
14723                 }
14724         }
14725         if (ndr_flags & NDR_BUFFERS) {
14726                 if (r->document_name) {
14727                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14728                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14729                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14730                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14731                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14732                                 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));
14733                         }
14734                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14735                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14737                 }
14738                 if (r->output_file) {
14739                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14740                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14743                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14744                                 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));
14745                         }
14746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14749                 }
14750                 if (r->datatype) {
14751                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14752                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14755                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14756                                 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));
14757                         }
14758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14761                 }
14762         }
14763         return NDR_ERR_SUCCESS;
14764 }
14765
14766 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14767 {
14768         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14769         ndr->depth++;
14770         ndr_print_ptr(ndr, "document_name", r->document_name);
14771         ndr->depth++;
14772         if (r->document_name) {
14773                 ndr_print_string(ndr, "document_name", r->document_name);
14774         }
14775         ndr->depth--;
14776         ndr_print_ptr(ndr, "output_file", r->output_file);
14777         ndr->depth++;
14778         if (r->output_file) {
14779                 ndr_print_string(ndr, "output_file", r->output_file);
14780         }
14781         ndr->depth--;
14782         ndr_print_ptr(ndr, "datatype", r->datatype);
14783         ndr->depth++;
14784         if (r->datatype) {
14785                 ndr_print_string(ndr, "datatype", r->datatype);
14786         }
14787         ndr->depth--;
14788         ndr->depth--;
14789 }
14790
14791 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14792 {
14793         if (ndr_flags & NDR_SCALARS) {
14794                 int level = ndr_push_get_switch_value(ndr, r);
14795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14796                 NDR_CHECK(ndr_push_union_align(ndr, 5));
14797                 switch (level) {
14798                         case 1: {
14799                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14800                         break; }
14801
14802                         case 2: {
14803                         break; }
14804
14805                         case 3: {
14806                         break; }
14807
14808                         default: {
14809                         break; }
14810
14811                 }
14812         }
14813         if (ndr_flags & NDR_BUFFERS) {
14814                 int level = ndr_push_get_switch_value(ndr, r);
14815                 switch (level) {
14816                         case 1:
14817                                 if (r->info1) {
14818                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14819                                 }
14820                         break;
14821
14822                         case 2:
14823                         break;
14824
14825                         case 3:
14826                         break;
14827
14828                         default:
14829                         break;
14830
14831                 }
14832         }
14833         return NDR_ERR_SUCCESS;
14834 }
14835
14836 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14837 {
14838         int level;
14839         uint32_t _level;
14840         TALLOC_CTX *_mem_save_info1_0;
14841         level = ndr_pull_get_switch_value(ndr, r);
14842         if (ndr_flags & NDR_SCALARS) {
14843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14844                 if (_level != level) {
14845                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
14846                 }
14847                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14848                 switch (level) {
14849                         case 1: {
14850                                 uint32_t _ptr_info1;
14851                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14852                                 if (_ptr_info1) {
14853                                         NDR_PULL_ALLOC(ndr, r->info1);
14854                                 } else {
14855                                         r->info1 = NULL;
14856                                 }
14857                         break; }
14858
14859                         case 2: {
14860                         break; }
14861
14862                         case 3: {
14863                         break; }
14864
14865                         default: {
14866                         break; }
14867
14868                 }
14869         }
14870         if (ndr_flags & NDR_BUFFERS) {
14871                 switch (level) {
14872                         case 1:
14873                                 if (r->info1) {
14874                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14875                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14876                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14877                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14878                                 }
14879                         break;
14880
14881                         case 2:
14882                         break;
14883
14884                         case 3:
14885                         break;
14886
14887                         default:
14888                         break;
14889
14890                 }
14891         }
14892         return NDR_ERR_SUCCESS;
14893 }
14894
14895 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14896 {
14897         int level;
14898         level = ndr_print_get_switch_value(ndr, r);
14899         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14900         switch (level) {
14901                 case 1:
14902                         ndr_print_ptr(ndr, "info1", r->info1);
14903                         ndr->depth++;
14904                         if (r->info1) {
14905                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14906                         }
14907                         ndr->depth--;
14908                 break;
14909
14910                 case 2:
14911                 break;
14912
14913                 case 3:
14914                 break;
14915
14916                 default:
14917                 break;
14918
14919         }
14920 }
14921
14922 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14923 {
14924         if (ndr_flags & NDR_SCALARS) {
14925                 NDR_CHECK(ndr_push_align(ndr, 4));
14926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14931                 {
14932                         uint32_t _flags_save_string = ndr->flags;
14933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14934                         {
14935                                 struct ndr_push *_ndr_extra_string;
14936                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14937                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14938                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14939                         }
14940                         ndr->flags = _flags_save_string;
14941                 }
14942         }
14943         if (ndr_flags & NDR_BUFFERS) {
14944         }
14945         return NDR_ERR_SUCCESS;
14946 }
14947
14948 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14949 {
14950         if (ndr_flags & NDR_SCALARS) {
14951                 NDR_CHECK(ndr_pull_align(ndr, 4));
14952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
14957                 {
14958                         uint32_t _flags_save_string = ndr->flags;
14959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14960                         {
14961                                 struct ndr_pull *_ndr_extra_string;
14962                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14963                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14964                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14965                         }
14966                         ndr->flags = _flags_save_string;
14967                 }
14968         }
14969         if (ndr_flags & NDR_BUFFERS) {
14970         }
14971         return NDR_ERR_SUCCESS;
14972 }
14973
14974 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14975 {
14976         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14977         ndr->depth++;
14978         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);
14979         ndr_print_uint32(ndr, "major", r->major);
14980         ndr_print_uint32(ndr, "minor", r->minor);
14981         ndr_print_uint32(ndr, "build", r->build);
14982         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
14983         ndr_print_string(ndr, "extra_string", r->extra_string);
14984         ndr->depth--;
14985 }
14986
14987 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14988 {
14989         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14990 }
14991
14992 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14993 {
14994         if (ndr_flags & NDR_SCALARS) {
14995                 NDR_CHECK(ndr_push_align(ndr, 4));
14996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15001                 {
15002                         uint32_t _flags_save_string = ndr->flags;
15003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15004                         {
15005                                 struct ndr_push *_ndr_extra_string;
15006                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15007                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15008                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15009                         }
15010                         ndr->flags = _flags_save_string;
15011                 }
15012                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15013                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15014                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15015                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15016                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15017         }
15018         if (ndr_flags & NDR_BUFFERS) {
15019         }
15020         return NDR_ERR_SUCCESS;
15021 }
15022
15023 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15024 {
15025         if (ndr_flags & NDR_SCALARS) {
15026                 NDR_CHECK(ndr_pull_align(ndr, 4));
15027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15032                 {
15033                         uint32_t _flags_save_string = ndr->flags;
15034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15035                         {
15036                                 struct ndr_pull *_ndr_extra_string;
15037                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15038                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15039                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15040                         }
15041                         ndr->flags = _flags_save_string;
15042                 }
15043                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15044                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15045                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15046                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15047                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15048         }
15049         if (ndr_flags & NDR_BUFFERS) {
15050         }
15051         return NDR_ERR_SUCCESS;
15052 }
15053
15054 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15055 {
15056         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15057         ndr->depth++;
15058         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);
15059         ndr_print_uint32(ndr, "major", r->major);
15060         ndr_print_uint32(ndr, "minor", r->minor);
15061         ndr_print_uint32(ndr, "build", r->build);
15062         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15063         ndr_print_string(ndr, "extra_string", r->extra_string);
15064         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15065         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15066         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15067         ndr_print_uint8(ndr, "product_type", r->product_type);
15068         ndr_print_uint8(ndr, "reserved", r->reserved);
15069         ndr->depth--;
15070 }
15071
15072 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15073 {
15074         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15075 }
15076
15077 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15078 {
15079         if (ndr_flags & NDR_SCALARS) {
15080                 int level = ndr_push_get_switch_value(ndr, r);
15081                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15082                 switch (level) {
15083                         case REG_NONE: {
15084                         break; }
15085
15086                         case REG_SZ: {
15087                                 {
15088                                         uint32_t _flags_save_string = ndr->flags;
15089                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15090                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15091                                         ndr->flags = _flags_save_string;
15092                                 }
15093                         break; }
15094
15095                         case REG_BINARY: {
15096                                 {
15097                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15098                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15099                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15100                                         ndr->flags = _flags_save_DATA_BLOB;
15101                                 }
15102                         break; }
15103
15104                         case REG_DWORD: {
15105                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15106                         break; }
15107
15108                         case REG_MULTI_SZ: {
15109                                 {
15110                                         uint32_t _flags_save_string_array = ndr->flags;
15111                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15112                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15113                                         ndr->flags = _flags_save_string_array;
15114                                 }
15115                         break; }
15116
15117                         default: {
15118                                 {
15119                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15120                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15121                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15122                                         ndr->flags = _flags_save_DATA_BLOB;
15123                                 }
15124                         break; }
15125
15126                 }
15127         }
15128         if (ndr_flags & NDR_BUFFERS) {
15129                 int level = ndr_push_get_switch_value(ndr, r);
15130                 switch (level) {
15131                         case REG_NONE:
15132                         break;
15133
15134                         case REG_SZ:
15135                         break;
15136
15137                         case REG_BINARY:
15138                         break;
15139
15140                         case REG_DWORD:
15141                         break;
15142
15143                         case REG_MULTI_SZ:
15144                         break;
15145
15146                         default:
15147                         break;
15148
15149                 }
15150         }
15151         return NDR_ERR_SUCCESS;
15152 }
15153
15154 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15155 {
15156         int level;
15157         level = ndr_pull_get_switch_value(ndr, r);
15158         if (ndr_flags & NDR_SCALARS) {
15159                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15160                 switch (level) {
15161                         case REG_NONE: {
15162                         break; }
15163
15164                         case REG_SZ: {
15165                                 {
15166                                         uint32_t _flags_save_string = ndr->flags;
15167                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15168                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15169                                         ndr->flags = _flags_save_string;
15170                                 }
15171                         break; }
15172
15173                         case REG_BINARY: {
15174                                 {
15175                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15176                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15177                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15178                                         ndr->flags = _flags_save_DATA_BLOB;
15179                                 }
15180                         break; }
15181
15182                         case REG_DWORD: {
15183                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15184                         break; }
15185
15186                         case REG_MULTI_SZ: {
15187                                 {
15188                                         uint32_t _flags_save_string_array = ndr->flags;
15189                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15190                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15191                                         ndr->flags = _flags_save_string_array;
15192                                 }
15193                         break; }
15194
15195                         default: {
15196                                 {
15197                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15198                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15199                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15200                                         ndr->flags = _flags_save_DATA_BLOB;
15201                                 }
15202                         break; }
15203
15204                 }
15205         }
15206         if (ndr_flags & NDR_BUFFERS) {
15207                 switch (level) {
15208                         case REG_NONE:
15209                         break;
15210
15211                         case REG_SZ:
15212                         break;
15213
15214                         case REG_BINARY:
15215                         break;
15216
15217                         case REG_DWORD:
15218                         break;
15219
15220                         case REG_MULTI_SZ:
15221                         break;
15222
15223                         default:
15224                         break;
15225
15226                 }
15227         }
15228         return NDR_ERR_SUCCESS;
15229 }
15230
15231 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15232 {
15233         int level;
15234         level = ndr_print_get_switch_value(ndr, r);
15235         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15236         switch (level) {
15237                 case REG_NONE:
15238                 break;
15239
15240                 case REG_SZ:
15241                         ndr_print_string(ndr, "string", r->string);
15242                 break;
15243
15244                 case REG_BINARY:
15245                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15246                 break;
15247
15248                 case REG_DWORD:
15249                         ndr_print_uint32(ndr, "value", r->value);
15250                 break;
15251
15252                 case REG_MULTI_SZ:
15253                         ndr_print_string_array(ndr, "string_array", r->string_array);
15254                 break;
15255
15256                 default:
15257                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15258                 break;
15259
15260         }
15261 }
15262
15263 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15264 {
15265         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
15266 }
15267
15268 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15269 {
15270         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
15271         return NDR_ERR_SUCCESS;
15272 }
15273
15274 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15275 {
15276         uint32_t v;
15277         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
15278         *r = v;
15279         return NDR_ERR_SUCCESS;
15280 }
15281
15282 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15283 {
15284         const char *val = NULL;
15285
15286         switch (r) {
15287                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15288                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15289                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15290         }
15291         ndr_print_enum(ndr, name, "ENUM", val, r);
15292 }
15293
15294 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15295 {
15296         if (ndr_flags & NDR_SCALARS) {
15297                 NDR_CHECK(ndr_push_align(ndr, 4));
15298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15300         }
15301         if (ndr_flags & NDR_BUFFERS) {
15302         }
15303         return NDR_ERR_SUCCESS;
15304 }
15305
15306 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15307 {
15308         if (ndr_flags & NDR_SCALARS) {
15309                 NDR_CHECK(ndr_pull_align(ndr, 4));
15310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15312         }
15313         if (ndr_flags & NDR_BUFFERS) {
15314         }
15315         return NDR_ERR_SUCCESS;
15316 }
15317
15318 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
15319 {
15320         ndr_print_struct(ndr, name, "spoolss_FormSize");
15321         ndr->depth++;
15322         ndr_print_uint32(ndr, "width", r->width);
15323         ndr_print_uint32(ndr, "height", r->height);
15324         ndr->depth--;
15325 }
15326
15327 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
15328 {
15329         if (ndr_flags & NDR_SCALARS) {
15330                 NDR_CHECK(ndr_push_align(ndr, 4));
15331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
15332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
15333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
15334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
15335         }
15336         if (ndr_flags & NDR_BUFFERS) {
15337         }
15338         return NDR_ERR_SUCCESS;
15339 }
15340
15341 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
15342 {
15343         if (ndr_flags & NDR_SCALARS) {
15344                 NDR_CHECK(ndr_pull_align(ndr, 4));
15345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
15346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
15347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
15348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
15349         }
15350         if (ndr_flags & NDR_BUFFERS) {
15351         }
15352         return NDR_ERR_SUCCESS;
15353 }
15354
15355 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
15356 {
15357         ndr_print_struct(ndr, name, "spoolss_FormArea");
15358         ndr->depth++;
15359         ndr_print_uint32(ndr, "left", r->left);
15360         ndr_print_uint32(ndr, "top", r->top);
15361         ndr_print_uint32(ndr, "right", r->right);
15362         ndr_print_uint32(ndr, "bottom", r->bottom);
15363         ndr->depth--;
15364 }
15365
15366 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
15367 {
15368         if (ndr_flags & NDR_SCALARS) {
15369                 NDR_CHECK(ndr_push_align(ndr, 5));
15370                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15371                 {
15372                         uint32_t _flags_save_string = ndr->flags;
15373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15374                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15375                         ndr->flags = _flags_save_string;
15376                 }
15377                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15378                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15379         }
15380         if (ndr_flags & NDR_BUFFERS) {
15381                 {
15382                         uint32_t _flags_save_string = ndr->flags;
15383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15384                         if (r->form_name) {
15385                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15386                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15387                         }
15388                         ndr->flags = _flags_save_string;
15389                 }
15390         }
15391         return NDR_ERR_SUCCESS;
15392 }
15393
15394 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
15395 {
15396         uint32_t _ptr_form_name;
15397         TALLOC_CTX *_mem_save_form_name_0;
15398         if (ndr_flags & NDR_SCALARS) {
15399                 NDR_CHECK(ndr_pull_align(ndr, 5));
15400                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15401                 {
15402                         uint32_t _flags_save_string = ndr->flags;
15403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15405                         if (_ptr_form_name) {
15406                                 NDR_PULL_ALLOC(ndr, r->form_name);
15407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15408                         } else {
15409                                 r->form_name = NULL;
15410                         }
15411                         ndr->flags = _flags_save_string;
15412                 }
15413                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15414                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15415         }
15416         if (ndr_flags & NDR_BUFFERS) {
15417                 {
15418                         uint32_t _flags_save_string = ndr->flags;
15419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15420                         if (r->form_name) {
15421                                 uint32_t _relative_save_offset;
15422                                 _relative_save_offset = ndr->offset;
15423                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15424                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15425                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15426                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15427                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15428                                 ndr->offset = _relative_save_offset;
15429                         }
15430                         ndr->flags = _flags_save_string;
15431                 }
15432         }
15433         return NDR_ERR_SUCCESS;
15434 }
15435
15436 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
15437 {
15438         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
15439         ndr->depth++;
15440         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15441         ndr_print_ptr(ndr, "form_name", r->form_name);
15442         ndr->depth++;
15443         if (r->form_name) {
15444                 ndr_print_string(ndr, "form_name", r->form_name);
15445         }
15446         ndr->depth--;
15447         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15448         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15449         ndr->depth--;
15450 }
15451
15452 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15453 {
15454         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
15455 }
15456
15457 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15458 {
15459         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15460         return NDR_ERR_SUCCESS;
15461 }
15462
15463 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15464 {
15465         uint32_t v;
15466         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15467         *r = v;
15468         return NDR_ERR_SUCCESS;
15469 }
15470
15471 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
15472 {
15473         ndr_print_uint32(ndr, name, r);
15474         ndr->depth++;
15475         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
15476         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
15477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
15478         ndr->depth--;
15479 }
15480
15481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
15482 {
15483         if (ndr_flags & NDR_SCALARS) {
15484                 NDR_CHECK(ndr_push_align(ndr, 5));
15485                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15486                 {
15487                         uint32_t _flags_save_string = ndr->flags;
15488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15490                         ndr->flags = _flags_save_string;
15491                 }
15492                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15493                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15494                 {
15495                         uint32_t _flags_save_string = ndr->flags;
15496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15497                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15498                         ndr->flags = _flags_save_string;
15499                 }
15500                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15501                 {
15502                         uint32_t _flags_save_string = ndr->flags;
15503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15505                         ndr->flags = _flags_save_string;
15506                 }
15507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15508                 {
15509                         uint32_t _flags_save_string = ndr->flags;
15510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15511                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15512                         ndr->flags = _flags_save_string;
15513                 }
15514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15515         }
15516         if (ndr_flags & NDR_BUFFERS) {
15517                 {
15518                         uint32_t _flags_save_string = ndr->flags;
15519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15520                         if (r->form_name) {
15521                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15522                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15523                         }
15524                         ndr->flags = _flags_save_string;
15525                 }
15526                 {
15527                         uint32_t _flags_save_string = ndr->flags;
15528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15529                         if (r->keyword) {
15530                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15531                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15532                         }
15533                         ndr->flags = _flags_save_string;
15534                 }
15535                 {
15536                         uint32_t _flags_save_string = ndr->flags;
15537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15538                         if (r->mui_dll) {
15539                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15540                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15541                         }
15542                         ndr->flags = _flags_save_string;
15543                 }
15544                 {
15545                         uint32_t _flags_save_string = ndr->flags;
15546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15547                         if (r->display_name) {
15548                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15549                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15550                         }
15551                         ndr->flags = _flags_save_string;
15552                 }
15553         }
15554         return NDR_ERR_SUCCESS;
15555 }
15556
15557 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15558 {
15559         uint32_t _ptr_form_name;
15560         TALLOC_CTX *_mem_save_form_name_0;
15561         uint32_t _ptr_keyword;
15562         TALLOC_CTX *_mem_save_keyword_0;
15563         uint32_t _ptr_mui_dll;
15564         TALLOC_CTX *_mem_save_mui_dll_0;
15565         uint32_t _ptr_display_name;
15566         TALLOC_CTX *_mem_save_display_name_0;
15567         if (ndr_flags & NDR_SCALARS) {
15568                 NDR_CHECK(ndr_pull_align(ndr, 5));
15569                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15570                 {
15571                         uint32_t _flags_save_string = ndr->flags;
15572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15573                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15574                         if (_ptr_form_name) {
15575                                 NDR_PULL_ALLOC(ndr, r->form_name);
15576                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15577                         } else {
15578                                 r->form_name = NULL;
15579                         }
15580                         ndr->flags = _flags_save_string;
15581                 }
15582                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15583                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15584                 {
15585                         uint32_t _flags_save_string = ndr->flags;
15586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15587                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15588                         if (_ptr_keyword) {
15589                                 NDR_PULL_ALLOC(ndr, r->keyword);
15590                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15591                         } else {
15592                                 r->keyword = NULL;
15593                         }
15594                         ndr->flags = _flags_save_string;
15595                 }
15596                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15597                 {
15598                         uint32_t _flags_save_string = ndr->flags;
15599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15600                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15601                         if (_ptr_mui_dll) {
15602                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15603                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15604                         } else {
15605                                 r->mui_dll = NULL;
15606                         }
15607                         ndr->flags = _flags_save_string;
15608                 }
15609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15610                 {
15611                         uint32_t _flags_save_string = ndr->flags;
15612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15613                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15614                         if (_ptr_display_name) {
15615                                 NDR_PULL_ALLOC(ndr, r->display_name);
15616                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15617                         } else {
15618                                 r->display_name = NULL;
15619                         }
15620                         ndr->flags = _flags_save_string;
15621                 }
15622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15623         }
15624         if (ndr_flags & NDR_BUFFERS) {
15625                 {
15626                         uint32_t _flags_save_string = ndr->flags;
15627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15628                         if (r->form_name) {
15629                                 uint32_t _relative_save_offset;
15630                                 _relative_save_offset = ndr->offset;
15631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15632                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15633                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15636                                 ndr->offset = _relative_save_offset;
15637                         }
15638                         ndr->flags = _flags_save_string;
15639                 }
15640                 {
15641                         uint32_t _flags_save_string = ndr->flags;
15642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15643                         if (r->keyword) {
15644                                 uint32_t _relative_save_offset;
15645                                 _relative_save_offset = ndr->offset;
15646                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15647                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15648                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15649                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15650                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15651                                 ndr->offset = _relative_save_offset;
15652                         }
15653                         ndr->flags = _flags_save_string;
15654                 }
15655                 {
15656                         uint32_t _flags_save_string = ndr->flags;
15657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15658                         if (r->mui_dll) {
15659                                 uint32_t _relative_save_offset;
15660                                 _relative_save_offset = ndr->offset;
15661                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15662                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15663                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15664                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15665                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15666                                 ndr->offset = _relative_save_offset;
15667                         }
15668                         ndr->flags = _flags_save_string;
15669                 }
15670                 {
15671                         uint32_t _flags_save_string = ndr->flags;
15672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15673                         if (r->display_name) {
15674                                 uint32_t _relative_save_offset;
15675                                 _relative_save_offset = ndr->offset;
15676                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15677                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15678                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15679                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15680                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15681                                 ndr->offset = _relative_save_offset;
15682                         }
15683                         ndr->flags = _flags_save_string;
15684                 }
15685         }
15686         return NDR_ERR_SUCCESS;
15687 }
15688
15689 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15690 {
15691         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15692         ndr->depth++;
15693         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15694         ndr_print_ptr(ndr, "form_name", r->form_name);
15695         ndr->depth++;
15696         if (r->form_name) {
15697                 ndr_print_string(ndr, "form_name", r->form_name);
15698         }
15699         ndr->depth--;
15700         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15701         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15702         ndr_print_ptr(ndr, "keyword", r->keyword);
15703         ndr->depth++;
15704         if (r->keyword) {
15705                 ndr_print_string(ndr, "keyword", r->keyword);
15706         }
15707         ndr->depth--;
15708         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15709         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15710         ndr->depth++;
15711         if (r->mui_dll) {
15712                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15713         }
15714         ndr->depth--;
15715         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15716         ndr_print_ptr(ndr, "display_name", r->display_name);
15717         ndr->depth++;
15718         if (r->display_name) {
15719                 ndr_print_string(ndr, "display_name", r->display_name);
15720         }
15721         ndr->depth--;
15722         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15723         ndr->depth--;
15724 }
15725
15726 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15727 {
15728         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15729 }
15730
15731 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15732 {
15733         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15734         if (ndr_flags & NDR_SCALARS) {
15735                 int level = ndr_push_get_switch_value(ndr, r);
15736                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15737                 switch (level) {
15738                         case 1: {
15739                                 NDR_CHECK(ndr_push_align(ndr, 5));
15740                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15741                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15742                         break; }
15743
15744                         case 2: {
15745                                 NDR_CHECK(ndr_push_align(ndr, 5));
15746                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15747                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15748                         break; }
15749
15750                         default: {
15751                         break; }
15752
15753                 }
15754         }
15755         if (ndr_flags & NDR_BUFFERS) {
15756                 int level = ndr_push_get_switch_value(ndr, r);
15757                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15758                 switch (level) {
15759                         case 1:
15760                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15761                         break;
15762
15763                         case 2:
15764                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15765                         break;
15766
15767                         default:
15768                         break;
15769
15770                 }
15771         }
15772         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15773         return NDR_ERR_SUCCESS;
15774 }
15775
15776 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15777 {
15778         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15779         int level;
15780         level = ndr_pull_get_switch_value(ndr, r);
15781         if (ndr_flags & NDR_SCALARS) {
15782                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15783                 switch (level) {
15784                         case 1: {
15785                                 NDR_CHECK(ndr_pull_align(ndr, 5));
15786                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15787                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15788                         break; }
15789
15790                         case 2: {
15791                                 NDR_CHECK(ndr_pull_align(ndr, 5));
15792                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15793                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15794                         break; }
15795
15796                         default: {
15797                         break; }
15798
15799                 }
15800         }
15801         if (ndr_flags & NDR_BUFFERS) {
15802                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15803                 switch (level) {
15804                         case 1:
15805                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15806                         break;
15807
15808                         case 2:
15809                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15810                         break;
15811
15812                         default:
15813                         break;
15814
15815                 }
15816         }
15817         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15818         return NDR_ERR_SUCCESS;
15819 }
15820
15821 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15822 {
15823         int level;
15824         level = ndr_print_get_switch_value(ndr, r);
15825         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15826         switch (level) {
15827                 case 1:
15828                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15829                 break;
15830
15831                 case 2:
15832                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15833                 break;
15834
15835                 default:
15836                 break;
15837
15838         }
15839 }
15840
15841 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15842 {
15843         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15844 }
15845
15846 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15847 {
15848         if (ndr_flags & NDR_SCALARS) {
15849                 NDR_CHECK(ndr_push_align(ndr, 5));
15850                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15851                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15852                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15853                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15854         }
15855         if (ndr_flags & NDR_BUFFERS) {
15856                 if (r->form_name) {
15857                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15861                 }
15862         }
15863         return NDR_ERR_SUCCESS;
15864 }
15865
15866 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15867 {
15868         uint32_t _ptr_form_name;
15869         TALLOC_CTX *_mem_save_form_name_0;
15870         if (ndr_flags & NDR_SCALARS) {
15871                 NDR_CHECK(ndr_pull_align(ndr, 5));
15872                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15874                 if (_ptr_form_name) {
15875                         NDR_PULL_ALLOC(ndr, r->form_name);
15876                 } else {
15877                         r->form_name = NULL;
15878                 }
15879                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15880                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15881         }
15882         if (ndr_flags & NDR_BUFFERS) {
15883                 if (r->form_name) {
15884                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15885                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15886                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15887                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15888                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15889                                 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));
15890                         }
15891                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15892                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15893                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15894                 }
15895         }
15896         return NDR_ERR_SUCCESS;
15897 }
15898
15899 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15900 {
15901         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15902         ndr->depth++;
15903         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15904         ndr_print_ptr(ndr, "form_name", r->form_name);
15905         ndr->depth++;
15906         if (r->form_name) {
15907                 ndr_print_string(ndr, "form_name", r->form_name);
15908         }
15909         ndr->depth--;
15910         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15911         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15912         ndr->depth--;
15913 }
15914
15915 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15916 {
15917         if (ndr_flags & NDR_SCALARS) {
15918                 NDR_CHECK(ndr_push_align(ndr, 5));
15919                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15920                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15921                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15922                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15923                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15924                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15925                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15927                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15929         }
15930         if (ndr_flags & NDR_BUFFERS) {
15931                 if (r->form_name) {
15932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15935                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15936                 }
15937                 if (r->keyword) {
15938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15940                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15941                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15942                 }
15943                 if (r->mui_dll) {
15944                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15947                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15948                 }
15949                 if (r->display_name) {
15950                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15951                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15952                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15953                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15954                 }
15955         }
15956         return NDR_ERR_SUCCESS;
15957 }
15958
15959 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15960 {
15961         uint32_t _ptr_form_name;
15962         TALLOC_CTX *_mem_save_form_name_0;
15963         uint32_t _ptr_keyword;
15964         TALLOC_CTX *_mem_save_keyword_0;
15965         uint32_t _ptr_mui_dll;
15966         TALLOC_CTX *_mem_save_mui_dll_0;
15967         uint32_t _ptr_display_name;
15968         TALLOC_CTX *_mem_save_display_name_0;
15969         if (ndr_flags & NDR_SCALARS) {
15970                 NDR_CHECK(ndr_pull_align(ndr, 5));
15971                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15973                 if (_ptr_form_name) {
15974                         NDR_PULL_ALLOC(ndr, r->form_name);
15975                 } else {
15976                         r->form_name = NULL;
15977                 }
15978                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15979                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15981                 if (_ptr_keyword) {
15982                         NDR_PULL_ALLOC(ndr, r->keyword);
15983                 } else {
15984                         r->keyword = NULL;
15985                 }
15986                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15988                 if (_ptr_mui_dll) {
15989                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15990                 } else {
15991                         r->mui_dll = NULL;
15992                 }
15993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15995                 if (_ptr_display_name) {
15996                         NDR_PULL_ALLOC(ndr, r->display_name);
15997                 } else {
15998                         r->display_name = NULL;
15999                 }
16000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16001         }
16002         if (ndr_flags & NDR_BUFFERS) {
16003                 if (r->form_name) {
16004                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16005                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16008                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16009                                 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));
16010                         }
16011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16012                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16014                 }
16015                 if (r->keyword) {
16016                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16017                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16020                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16021                                 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));
16022                         }
16023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16026                 }
16027                 if (r->mui_dll) {
16028                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16029                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16032                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16033                                 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));
16034                         }
16035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16036                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16038                 }
16039                 if (r->display_name) {
16040                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16041                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16044                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16045                                 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));
16046                         }
16047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16050                 }
16051         }
16052         return NDR_ERR_SUCCESS;
16053 }
16054
16055 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16056 {
16057         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16058         ndr->depth++;
16059         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16060         ndr_print_ptr(ndr, "form_name", r->form_name);
16061         ndr->depth++;
16062         if (r->form_name) {
16063                 ndr_print_string(ndr, "form_name", r->form_name);
16064         }
16065         ndr->depth--;
16066         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16067         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16068         ndr_print_ptr(ndr, "keyword", r->keyword);
16069         ndr->depth++;
16070         if (r->keyword) {
16071                 ndr_print_string(ndr, "keyword", r->keyword);
16072         }
16073         ndr->depth--;
16074         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16075         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16076         ndr->depth++;
16077         if (r->mui_dll) {
16078                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16079         }
16080         ndr->depth--;
16081         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16082         ndr_print_ptr(ndr, "display_name", r->display_name);
16083         ndr->depth++;
16084         if (r->display_name) {
16085                 ndr_print_string(ndr, "display_name", r->display_name);
16086         }
16087         ndr->depth--;
16088         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16089         ndr->depth--;
16090 }
16091
16092 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16093 {
16094         if (ndr_flags & NDR_SCALARS) {
16095                 int level = ndr_push_get_switch_value(ndr, r);
16096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16097                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16098                 switch (level) {
16099                         case 1: {
16100                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16101                         break; }
16102
16103                         case 2: {
16104                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16105                         break; }
16106
16107                         default:
16108                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16109                 }
16110         }
16111         if (ndr_flags & NDR_BUFFERS) {
16112                 int level = ndr_push_get_switch_value(ndr, r);
16113                 switch (level) {
16114                         case 1:
16115                                 if (r->info1) {
16116                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16117                                 }
16118                         break;
16119
16120                         case 2:
16121                                 if (r->info2) {
16122                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16123                                 }
16124                         break;
16125
16126                         default:
16127                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16128                 }
16129         }
16130         return NDR_ERR_SUCCESS;
16131 }
16132
16133 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16134 {
16135         int level;
16136         uint32_t _level;
16137         TALLOC_CTX *_mem_save_info1_0;
16138         TALLOC_CTX *_mem_save_info2_0;
16139         level = ndr_pull_get_switch_value(ndr, r);
16140         if (ndr_flags & NDR_SCALARS) {
16141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16142                 if (_level != level) {
16143                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16144                 }
16145                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16146                 switch (level) {
16147                         case 1: {
16148                                 uint32_t _ptr_info1;
16149                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16150                                 if (_ptr_info1) {
16151                                         NDR_PULL_ALLOC(ndr, r->info1);
16152                                 } else {
16153                                         r->info1 = NULL;
16154                                 }
16155                         break; }
16156
16157                         case 2: {
16158                                 uint32_t _ptr_info2;
16159                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16160                                 if (_ptr_info2) {
16161                                         NDR_PULL_ALLOC(ndr, r->info2);
16162                                 } else {
16163                                         r->info2 = NULL;
16164                                 }
16165                         break; }
16166
16167                         default:
16168                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16169                 }
16170         }
16171         if (ndr_flags & NDR_BUFFERS) {
16172                 switch (level) {
16173                         case 1:
16174                                 if (r->info1) {
16175                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16176                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16177                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16178                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16179                                 }
16180                         break;
16181
16182                         case 2:
16183                                 if (r->info2) {
16184                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16185                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16186                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16187                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16188                                 }
16189                         break;
16190
16191                         default:
16192                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16193                 }
16194         }
16195         return NDR_ERR_SUCCESS;
16196 }
16197
16198 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16199 {
16200         int level;
16201         level = ndr_print_get_switch_value(ndr, r);
16202         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16203         switch (level) {
16204                 case 1:
16205                         ndr_print_ptr(ndr, "info1", r->info1);
16206                         ndr->depth++;
16207                         if (r->info1) {
16208                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16209                         }
16210                         ndr->depth--;
16211                 break;
16212
16213                 case 2:
16214                         ndr_print_ptr(ndr, "info2", r->info2);
16215                         ndr->depth++;
16216                         if (r->info2) {
16217                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16218                         }
16219                         ndr->depth--;
16220                 break;
16221
16222                 default:
16223                         ndr_print_bad_level(ndr, name, level);
16224         }
16225 }
16226
16227 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16228 {
16229         if (ndr_flags & NDR_SCALARS) {
16230                 NDR_CHECK(ndr_push_align(ndr, 5));
16231                 {
16232                         uint32_t _flags_save_string = ndr->flags;
16233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16235                         ndr->flags = _flags_save_string;
16236                 }
16237         }
16238         if (ndr_flags & NDR_BUFFERS) {
16239                 {
16240                         uint32_t _flags_save_string = ndr->flags;
16241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16242                         if (r->port_name) {
16243                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16244                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16245                         }
16246                         ndr->flags = _flags_save_string;
16247                 }
16248         }
16249         return NDR_ERR_SUCCESS;
16250 }
16251
16252 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16253 {
16254         uint32_t _ptr_port_name;
16255         TALLOC_CTX *_mem_save_port_name_0;
16256         if (ndr_flags & NDR_SCALARS) {
16257                 NDR_CHECK(ndr_pull_align(ndr, 5));
16258                 {
16259                         uint32_t _flags_save_string = ndr->flags;
16260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16261                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16262                         if (_ptr_port_name) {
16263                                 NDR_PULL_ALLOC(ndr, r->port_name);
16264                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16265                         } else {
16266                                 r->port_name = NULL;
16267                         }
16268                         ndr->flags = _flags_save_string;
16269                 }
16270         }
16271         if (ndr_flags & NDR_BUFFERS) {
16272                 {
16273                         uint32_t _flags_save_string = ndr->flags;
16274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16275                         if (r->port_name) {
16276                                 uint32_t _relative_save_offset;
16277                                 _relative_save_offset = ndr->offset;
16278                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16279                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16280                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16281                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16282                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16283                                 ndr->offset = _relative_save_offset;
16284                         }
16285                         ndr->flags = _flags_save_string;
16286                 }
16287         }
16288         return NDR_ERR_SUCCESS;
16289 }
16290
16291 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
16292 {
16293         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
16294         ndr->depth++;
16295         ndr_print_ptr(ndr, "port_name", r->port_name);
16296         ndr->depth++;
16297         if (r->port_name) {
16298                 ndr_print_string(ndr, "port_name", r->port_name);
16299         }
16300         ndr->depth--;
16301         ndr->depth--;
16302 }
16303
16304 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16305 {
16306         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
16307 }
16308
16309 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16310 {
16311         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16312         return NDR_ERR_SUCCESS;
16313 }
16314
16315 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16316 {
16317         uint32_t v;
16318         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16319         *r = v;
16320         return NDR_ERR_SUCCESS;
16321 }
16322
16323 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
16324 {
16325         ndr_print_uint32(ndr, name, r);
16326         ndr->depth++;
16327         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
16328         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
16329         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
16330         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
16331         ndr->depth--;
16332 }
16333
16334 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
16335 {
16336         if (ndr_flags & NDR_SCALARS) {
16337                 NDR_CHECK(ndr_push_align(ndr, 5));
16338                 {
16339                         uint32_t _flags_save_string = ndr->flags;
16340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16341                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16342                         ndr->flags = _flags_save_string;
16343                 }
16344                 {
16345                         uint32_t _flags_save_string = ndr->flags;
16346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16347                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16348                         ndr->flags = _flags_save_string;
16349                 }
16350                 {
16351                         uint32_t _flags_save_string = ndr->flags;
16352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16353                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
16354                         ndr->flags = _flags_save_string;
16355                 }
16356                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
16357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16358         }
16359         if (ndr_flags & NDR_BUFFERS) {
16360                 {
16361                         uint32_t _flags_save_string = ndr->flags;
16362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16363                         if (r->port_name) {
16364                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16365                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16366                         }
16367                         ndr->flags = _flags_save_string;
16368                 }
16369                 {
16370                         uint32_t _flags_save_string = ndr->flags;
16371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16372                         if (r->monitor_name) {
16373                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16374                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16375                         }
16376                         ndr->flags = _flags_save_string;
16377                 }
16378                 {
16379                         uint32_t _flags_save_string = ndr->flags;
16380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16381                         if (r->description) {
16382                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
16383                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
16384                         }
16385                         ndr->flags = _flags_save_string;
16386                 }
16387         }
16388         return NDR_ERR_SUCCESS;
16389 }
16390
16391 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
16392 {
16393         uint32_t _ptr_port_name;
16394         TALLOC_CTX *_mem_save_port_name_0;
16395         uint32_t _ptr_monitor_name;
16396         TALLOC_CTX *_mem_save_monitor_name_0;
16397         uint32_t _ptr_description;
16398         TALLOC_CTX *_mem_save_description_0;
16399         if (ndr_flags & NDR_SCALARS) {
16400                 NDR_CHECK(ndr_pull_align(ndr, 5));
16401                 {
16402                         uint32_t _flags_save_string = ndr->flags;
16403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16405                         if (_ptr_port_name) {
16406                                 NDR_PULL_ALLOC(ndr, r->port_name);
16407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16408                         } else {
16409                                 r->port_name = NULL;
16410                         }
16411                         ndr->flags = _flags_save_string;
16412                 }
16413                 {
16414                         uint32_t _flags_save_string = ndr->flags;
16415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16416                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16417                         if (_ptr_monitor_name) {
16418                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16419                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16420                         } else {
16421                                 r->monitor_name = NULL;
16422                         }
16423                         ndr->flags = _flags_save_string;
16424                 }
16425                 {
16426                         uint32_t _flags_save_string = ndr->flags;
16427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16428                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
16429                         if (_ptr_description) {
16430                                 NDR_PULL_ALLOC(ndr, r->description);
16431                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
16432                         } else {
16433                                 r->description = NULL;
16434                         }
16435                         ndr->flags = _flags_save_string;
16436                 }
16437                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
16438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16439         }
16440         if (ndr_flags & NDR_BUFFERS) {
16441                 {
16442                         uint32_t _flags_save_string = ndr->flags;
16443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16444                         if (r->port_name) {
16445                                 uint32_t _relative_save_offset;
16446                                 _relative_save_offset = ndr->offset;
16447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16448                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16449                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16452                                 ndr->offset = _relative_save_offset;
16453                         }
16454                         ndr->flags = _flags_save_string;
16455                 }
16456                 {
16457                         uint32_t _flags_save_string = ndr->flags;
16458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16459                         if (r->monitor_name) {
16460                                 uint32_t _relative_save_offset;
16461                                 _relative_save_offset = ndr->offset;
16462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16463                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16464                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16467                                 ndr->offset = _relative_save_offset;
16468                         }
16469                         ndr->flags = _flags_save_string;
16470                 }
16471                 {
16472                         uint32_t _flags_save_string = ndr->flags;
16473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16474                         if (r->description) {
16475                                 uint32_t _relative_save_offset;
16476                                 _relative_save_offset = ndr->offset;
16477                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
16478                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
16479                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
16480                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
16481                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
16482                                 ndr->offset = _relative_save_offset;
16483                         }
16484                         ndr->flags = _flags_save_string;
16485                 }
16486         }
16487         return NDR_ERR_SUCCESS;
16488 }
16489
16490 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
16491 {
16492         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
16493         ndr->depth++;
16494         ndr_print_ptr(ndr, "port_name", r->port_name);
16495         ndr->depth++;
16496         if (r->port_name) {
16497                 ndr_print_string(ndr, "port_name", r->port_name);
16498         }
16499         ndr->depth--;
16500         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16501         ndr->depth++;
16502         if (r->monitor_name) {
16503                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16504         }
16505         ndr->depth--;
16506         ndr_print_ptr(ndr, "description", r->description);
16507         ndr->depth++;
16508         if (r->description) {
16509                 ndr_print_string(ndr, "description", r->description);
16510         }
16511         ndr->depth--;
16512         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
16513         ndr_print_uint32(ndr, "reserved", r->reserved);
16514         ndr->depth--;
16515 }
16516
16517 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16518 {
16519         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
16520 }
16521
16522 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
16523 {
16524         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16525         return NDR_ERR_SUCCESS;
16526 }
16527
16528 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16529 {
16530         uint32_t v;
16531         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16532         *r = v;
16533         return NDR_ERR_SUCCESS;
16534 }
16535
16536 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16537 {
16538         const char *val = NULL;
16539
16540         switch (r) {
16541                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16542                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16543                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16544                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16545                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16546                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16547                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16548                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16549                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16550                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16551                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16552                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16553                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16554         }
16555         ndr_print_enum(ndr, name, "ENUM", val, r);
16556 }
16557
16558 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16559 {
16560         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16561         return NDR_ERR_SUCCESS;
16562 }
16563
16564 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16565 {
16566         uint32_t v;
16567         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16568         *r = v;
16569         return NDR_ERR_SUCCESS;
16570 }
16571
16572 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16573 {
16574         const char *val = NULL;
16575
16576         switch (r) {
16577                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16578                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16579                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16580         }
16581         ndr_print_enum(ndr, name, "ENUM", val, r);
16582 }
16583
16584 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16585 {
16586         if (ndr_flags & NDR_SCALARS) {
16587                 NDR_CHECK(ndr_push_align(ndr, 5));
16588                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16589                 {
16590                         uint32_t _flags_save_string = ndr->flags;
16591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16592                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16593                         ndr->flags = _flags_save_string;
16594                 }
16595                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16596         }
16597         if (ndr_flags & NDR_BUFFERS) {
16598                 {
16599                         uint32_t _flags_save_string = ndr->flags;
16600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16601                         if (r->status_string) {
16602                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16603                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16604                         }
16605                         ndr->flags = _flags_save_string;
16606                 }
16607         }
16608         return NDR_ERR_SUCCESS;
16609 }
16610
16611 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16612 {
16613         uint32_t _ptr_status_string;
16614         TALLOC_CTX *_mem_save_status_string_0;
16615         if (ndr_flags & NDR_SCALARS) {
16616                 NDR_CHECK(ndr_pull_align(ndr, 5));
16617                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16618                 {
16619                         uint32_t _flags_save_string = ndr->flags;
16620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16621                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16622                         if (_ptr_status_string) {
16623                                 NDR_PULL_ALLOC(ndr, r->status_string);
16624                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16625                         } else {
16626                                 r->status_string = NULL;
16627                         }
16628                         ndr->flags = _flags_save_string;
16629                 }
16630                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16631         }
16632         if (ndr_flags & NDR_BUFFERS) {
16633                 {
16634                         uint32_t _flags_save_string = ndr->flags;
16635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16636                         if (r->status_string) {
16637                                 uint32_t _relative_save_offset;
16638                                 _relative_save_offset = ndr->offset;
16639                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16640                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16641                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16642                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16643                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16644                                 ndr->offset = _relative_save_offset;
16645                         }
16646                         ndr->flags = _flags_save_string;
16647                 }
16648         }
16649         return NDR_ERR_SUCCESS;
16650 }
16651
16652 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16653 {
16654         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16655         ndr->depth++;
16656         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16657         ndr_print_ptr(ndr, "status_string", r->status_string);
16658         ndr->depth++;
16659         if (r->status_string) {
16660                 ndr_print_string(ndr, "status_string", r->status_string);
16661         }
16662         ndr->depth--;
16663         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16664         ndr->depth--;
16665 }
16666
16667 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16668 {
16669         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16670 }
16671
16672 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16673 {
16674         if (ndr_flags & NDR_SCALARS) {
16675                 NDR_CHECK(ndr_push_align(ndr, 5));
16676                 {
16677                         uint32_t _flags_save_string = ndr->flags;
16678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16679                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16680                         ndr->flags = _flags_save_string;
16681                 }
16682                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16683         }
16684         if (ndr_flags & NDR_BUFFERS) {
16685                 {
16686                         uint32_t _flags_save_string = ndr->flags;
16687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16688                         if (r->port_name) {
16689                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16690                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16691                         }
16692                         ndr->flags = _flags_save_string;
16693                 }
16694         }
16695         return NDR_ERR_SUCCESS;
16696 }
16697
16698 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16699 {
16700         uint32_t _ptr_port_name;
16701         TALLOC_CTX *_mem_save_port_name_0;
16702         if (ndr_flags & NDR_SCALARS) {
16703                 NDR_CHECK(ndr_pull_align(ndr, 5));
16704                 {
16705                         uint32_t _flags_save_string = ndr->flags;
16706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16707                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16708                         if (_ptr_port_name) {
16709                                 NDR_PULL_ALLOC(ndr, r->port_name);
16710                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16711                         } else {
16712                                 r->port_name = NULL;
16713                         }
16714                         ndr->flags = _flags_save_string;
16715                 }
16716                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16717         }
16718         if (ndr_flags & NDR_BUFFERS) {
16719                 {
16720                         uint32_t _flags_save_string = ndr->flags;
16721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16722                         if (r->port_name) {
16723                                 uint32_t _relative_save_offset;
16724                                 _relative_save_offset = ndr->offset;
16725                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16726                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16727                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16728                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16729                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16730                                 ndr->offset = _relative_save_offset;
16731                         }
16732                         ndr->flags = _flags_save_string;
16733                 }
16734         }
16735         return NDR_ERR_SUCCESS;
16736 }
16737
16738 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16739 {
16740         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16741         ndr->depth++;
16742         ndr_print_ptr(ndr, "port_name", r->port_name);
16743         ndr->depth++;
16744         if (r->port_name) {
16745                 ndr_print_string(ndr, "port_name", r->port_name);
16746         }
16747         ndr->depth--;
16748         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16749         ndr->depth--;
16750 }
16751
16752 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16753 {
16754         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16755 }
16756
16757 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16758 {
16759         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16760         if (ndr_flags & NDR_SCALARS) {
16761                 int level = ndr_push_get_switch_value(ndr, r);
16762                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16763                 switch (level) {
16764                         case 1: {
16765                                 NDR_CHECK(ndr_push_align(ndr, 5));
16766                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16767                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16768                         break; }
16769
16770                         case 2: {
16771                                 NDR_CHECK(ndr_push_align(ndr, 5));
16772                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16773                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16774                         break; }
16775
16776                         case 3: {
16777                                 NDR_CHECK(ndr_push_align(ndr, 5));
16778                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16779                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16780                         break; }
16781
16782                         case 0xff: {
16783                                 NDR_CHECK(ndr_push_align(ndr, 5));
16784                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16785                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16786                         break; }
16787
16788                         default: {
16789                         break; }
16790
16791                 }
16792         }
16793         if (ndr_flags & NDR_BUFFERS) {
16794                 int level = ndr_push_get_switch_value(ndr, r);
16795                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16796                 switch (level) {
16797                         case 1:
16798                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16799                         break;
16800
16801                         case 2:
16802                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16803                         break;
16804
16805                         case 3:
16806                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16807                         break;
16808
16809                         case 0xff:
16810                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16811                         break;
16812
16813                         default:
16814                         break;
16815
16816                 }
16817         }
16818         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16819         return NDR_ERR_SUCCESS;
16820 }
16821
16822 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16823 {
16824         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16825         int level;
16826         level = ndr_pull_get_switch_value(ndr, r);
16827         if (ndr_flags & NDR_SCALARS) {
16828                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16829                 switch (level) {
16830                         case 1: {
16831                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16832                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16833                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16834                         break; }
16835
16836                         case 2: {
16837                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16838                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16839                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16840                         break; }
16841
16842                         case 3: {
16843                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16844                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16845                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16846                         break; }
16847
16848                         case 0xff: {
16849                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16850                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16851                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16852                         break; }
16853
16854                         default: {
16855                         break; }
16856
16857                 }
16858         }
16859         if (ndr_flags & NDR_BUFFERS) {
16860                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16861                 switch (level) {
16862                         case 1:
16863                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16864                         break;
16865
16866                         case 2:
16867                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16868                         break;
16869
16870                         case 3:
16871                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16872                         break;
16873
16874                         case 0xff:
16875                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16876                         break;
16877
16878                         default:
16879                         break;
16880
16881                 }
16882         }
16883         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16884         return NDR_ERR_SUCCESS;
16885 }
16886
16887 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16888 {
16889         int level;
16890         level = ndr_print_get_switch_value(ndr, r);
16891         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16892         switch (level) {
16893                 case 1:
16894                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16895                 break;
16896
16897                 case 2:
16898                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16899                 break;
16900
16901                 case 3:
16902                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16903                 break;
16904
16905                 case 0xff:
16906                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16907                 break;
16908
16909                 default:
16910                 break;
16911
16912         }
16913 }
16914
16915 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16916 {
16917         if (ndr_flags & NDR_SCALARS) {
16918                 NDR_CHECK(ndr_push_align(ndr, 5));
16919                 {
16920                         uint32_t _flags_save_string = ndr->flags;
16921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16922                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16923                         ndr->flags = _flags_save_string;
16924                 }
16925         }
16926         if (ndr_flags & NDR_BUFFERS) {
16927                 {
16928                         uint32_t _flags_save_string = ndr->flags;
16929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16930                         if (r->monitor_name) {
16931                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16932                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16933                         }
16934                         ndr->flags = _flags_save_string;
16935                 }
16936         }
16937         return NDR_ERR_SUCCESS;
16938 }
16939
16940 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16941 {
16942         uint32_t _ptr_monitor_name;
16943         TALLOC_CTX *_mem_save_monitor_name_0;
16944         if (ndr_flags & NDR_SCALARS) {
16945                 NDR_CHECK(ndr_pull_align(ndr, 5));
16946                 {
16947                         uint32_t _flags_save_string = ndr->flags;
16948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16949                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16950                         if (_ptr_monitor_name) {
16951                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16952                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16953                         } else {
16954                                 r->monitor_name = NULL;
16955                         }
16956                         ndr->flags = _flags_save_string;
16957                 }
16958         }
16959         if (ndr_flags & NDR_BUFFERS) {
16960                 {
16961                         uint32_t _flags_save_string = ndr->flags;
16962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16963                         if (r->monitor_name) {
16964                                 uint32_t _relative_save_offset;
16965                                 _relative_save_offset = ndr->offset;
16966                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16967                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16968                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16969                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16970                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16971                                 ndr->offset = _relative_save_offset;
16972                         }
16973                         ndr->flags = _flags_save_string;
16974                 }
16975         }
16976         return NDR_ERR_SUCCESS;
16977 }
16978
16979 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16980 {
16981         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16982         ndr->depth++;
16983         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16984         ndr->depth++;
16985         if (r->monitor_name) {
16986                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16987         }
16988         ndr->depth--;
16989         ndr->depth--;
16990 }
16991
16992 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16993 {
16994         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16995 }
16996
16997 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16998 {
16999         if (ndr_flags & NDR_SCALARS) {
17000                 NDR_CHECK(ndr_push_align(ndr, 5));
17001                 {
17002                         uint32_t _flags_save_string = ndr->flags;
17003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17004                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17005                         ndr->flags = _flags_save_string;
17006                 }
17007                 {
17008                         uint32_t _flags_save_string = ndr->flags;
17009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17010                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17011                         ndr->flags = _flags_save_string;
17012                 }
17013                 {
17014                         uint32_t _flags_save_string = ndr->flags;
17015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17016                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17017                         ndr->flags = _flags_save_string;
17018                 }
17019         }
17020         if (ndr_flags & NDR_BUFFERS) {
17021                 {
17022                         uint32_t _flags_save_string = ndr->flags;
17023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17024                         if (r->monitor_name) {
17025                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17026                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17027                         }
17028                         ndr->flags = _flags_save_string;
17029                 }
17030                 {
17031                         uint32_t _flags_save_string = ndr->flags;
17032                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17033                         if (r->environment) {
17034                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
17035                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17036                         }
17037                         ndr->flags = _flags_save_string;
17038                 }
17039                 {
17040                         uint32_t _flags_save_string = ndr->flags;
17041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17042                         if (r->dll_name) {
17043                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
17044                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17045                         }
17046                         ndr->flags = _flags_save_string;
17047                 }
17048         }
17049         return NDR_ERR_SUCCESS;
17050 }
17051
17052 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17053 {
17054         uint32_t _ptr_monitor_name;
17055         TALLOC_CTX *_mem_save_monitor_name_0;
17056         uint32_t _ptr_environment;
17057         TALLOC_CTX *_mem_save_environment_0;
17058         uint32_t _ptr_dll_name;
17059         TALLOC_CTX *_mem_save_dll_name_0;
17060         if (ndr_flags & NDR_SCALARS) {
17061                 NDR_CHECK(ndr_pull_align(ndr, 5));
17062                 {
17063                         uint32_t _flags_save_string = ndr->flags;
17064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17065                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17066                         if (_ptr_monitor_name) {
17067                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17068                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17069                         } else {
17070                                 r->monitor_name = NULL;
17071                         }
17072                         ndr->flags = _flags_save_string;
17073                 }
17074                 {
17075                         uint32_t _flags_save_string = ndr->flags;
17076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17077                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17078                         if (_ptr_environment) {
17079                                 NDR_PULL_ALLOC(ndr, r->environment);
17080                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17081                         } else {
17082                                 r->environment = NULL;
17083                         }
17084                         ndr->flags = _flags_save_string;
17085                 }
17086                 {
17087                         uint32_t _flags_save_string = ndr->flags;
17088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17089                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17090                         if (_ptr_dll_name) {
17091                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17092                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17093                         } else {
17094                                 r->dll_name = NULL;
17095                         }
17096                         ndr->flags = _flags_save_string;
17097                 }
17098         }
17099         if (ndr_flags & NDR_BUFFERS) {
17100                 {
17101                         uint32_t _flags_save_string = ndr->flags;
17102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17103                         if (r->monitor_name) {
17104                                 uint32_t _relative_save_offset;
17105                                 _relative_save_offset = ndr->offset;
17106                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17107                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17108                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17109                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17110                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17111                                 ndr->offset = _relative_save_offset;
17112                         }
17113                         ndr->flags = _flags_save_string;
17114                 }
17115                 {
17116                         uint32_t _flags_save_string = ndr->flags;
17117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17118                         if (r->environment) {
17119                                 uint32_t _relative_save_offset;
17120                                 _relative_save_offset = ndr->offset;
17121                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17122                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17123                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17124                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17125                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17126                                 ndr->offset = _relative_save_offset;
17127                         }
17128                         ndr->flags = _flags_save_string;
17129                 }
17130                 {
17131                         uint32_t _flags_save_string = ndr->flags;
17132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17133                         if (r->dll_name) {
17134                                 uint32_t _relative_save_offset;
17135                                 _relative_save_offset = ndr->offset;
17136                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17137                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17138                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17139                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17140                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17141                                 ndr->offset = _relative_save_offset;
17142                         }
17143                         ndr->flags = _flags_save_string;
17144                 }
17145         }
17146         return NDR_ERR_SUCCESS;
17147 }
17148
17149 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17150 {
17151         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17152         ndr->depth++;
17153         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17154         ndr->depth++;
17155         if (r->monitor_name) {
17156                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17157         }
17158         ndr->depth--;
17159         ndr_print_ptr(ndr, "environment", r->environment);
17160         ndr->depth++;
17161         if (r->environment) {
17162                 ndr_print_string(ndr, "environment", r->environment);
17163         }
17164         ndr->depth--;
17165         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17166         ndr->depth++;
17167         if (r->dll_name) {
17168                 ndr_print_string(ndr, "dll_name", r->dll_name);
17169         }
17170         ndr->depth--;
17171         ndr->depth--;
17172 }
17173
17174 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17175 {
17176         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17177 }
17178
17179 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17180 {
17181         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17182         if (ndr_flags & NDR_SCALARS) {
17183                 int level = ndr_push_get_switch_value(ndr, r);
17184                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17185                 switch (level) {
17186                         case 1: {
17187                                 NDR_CHECK(ndr_push_align(ndr, 5));
17188                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17189                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17190                         break; }
17191
17192                         case 2: {
17193                                 NDR_CHECK(ndr_push_align(ndr, 5));
17194                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17195                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17196                         break; }
17197
17198                         default: {
17199                         break; }
17200
17201                 }
17202         }
17203         if (ndr_flags & NDR_BUFFERS) {
17204                 int level = ndr_push_get_switch_value(ndr, r);
17205                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17206                 switch (level) {
17207                         case 1:
17208                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17209                         break;
17210
17211                         case 2:
17212                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17213                         break;
17214
17215                         default:
17216                         break;
17217
17218                 }
17219         }
17220         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17221         return NDR_ERR_SUCCESS;
17222 }
17223
17224 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17225 {
17226         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17227         int level;
17228         level = ndr_pull_get_switch_value(ndr, r);
17229         if (ndr_flags & NDR_SCALARS) {
17230                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17231                 switch (level) {
17232                         case 1: {
17233                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17234                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17235                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17236                         break; }
17237
17238                         case 2: {
17239                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17240                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17241                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17242                         break; }
17243
17244                         default: {
17245                         break; }
17246
17247                 }
17248         }
17249         if (ndr_flags & NDR_BUFFERS) {
17250                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17251                 switch (level) {
17252                         case 1:
17253                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17254                         break;
17255
17256                         case 2:
17257                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17258                         break;
17259
17260                         default:
17261                         break;
17262
17263                 }
17264         }
17265         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17266         return NDR_ERR_SUCCESS;
17267 }
17268
17269 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
17270 {
17271         int level;
17272         level = ndr_print_get_switch_value(ndr, r);
17273         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
17274         switch (level) {
17275                 case 1:
17276                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
17277                 break;
17278
17279                 case 2:
17280                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
17281                 break;
17282
17283                 default:
17284                 break;
17285
17286         }
17287 }
17288
17289 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
17290 {
17291         if (ndr_flags & NDR_SCALARS) {
17292                 NDR_CHECK(ndr_push_align(ndr, 5));
17293                 {
17294                         uint32_t _flags_save_string = ndr->flags;
17295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
17297                         ndr->flags = _flags_save_string;
17298                 }
17299         }
17300         if (ndr_flags & NDR_BUFFERS) {
17301                 {
17302                         uint32_t _flags_save_string = ndr->flags;
17303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17304                         if (r->name_array) {
17305                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
17306                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
17307                         }
17308                         ndr->flags = _flags_save_string;
17309                 }
17310         }
17311         return NDR_ERR_SUCCESS;
17312 }
17313
17314 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
17315 {
17316         uint32_t _ptr_name_array;
17317         TALLOC_CTX *_mem_save_name_array_0;
17318         if (ndr_flags & NDR_SCALARS) {
17319                 NDR_CHECK(ndr_pull_align(ndr, 5));
17320                 {
17321                         uint32_t _flags_save_string = ndr->flags;
17322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17323                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
17324                         if (_ptr_name_array) {
17325                                 NDR_PULL_ALLOC(ndr, r->name_array);
17326                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
17327                         } else {
17328                                 r->name_array = NULL;
17329                         }
17330                         ndr->flags = _flags_save_string;
17331                 }
17332         }
17333         if (ndr_flags & NDR_BUFFERS) {
17334                 {
17335                         uint32_t _flags_save_string = ndr->flags;
17336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17337                         if (r->name_array) {
17338                                 uint32_t _relative_save_offset;
17339                                 _relative_save_offset = ndr->offset;
17340                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
17341                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
17342                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
17343                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
17344                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
17345                                 ndr->offset = _relative_save_offset;
17346                         }
17347                         ndr->flags = _flags_save_string;
17348                 }
17349         }
17350         return NDR_ERR_SUCCESS;
17351 }
17352
17353 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
17354 {
17355         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
17356         ndr->depth++;
17357         ndr_print_ptr(ndr, "name_array", r->name_array);
17358         ndr->depth++;
17359         if (r->name_array) {
17360                 ndr_print_string(ndr, "name_array", r->name_array);
17361         }
17362         ndr->depth--;
17363         ndr->depth--;
17364 }
17365
17366 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17367 {
17368         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
17369 }
17370
17371 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
17372 {
17373         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17374         if (ndr_flags & NDR_SCALARS) {
17375                 int level = ndr_push_get_switch_value(ndr, r);
17376                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17377                 switch (level) {
17378                         case 1: {
17379                                 NDR_CHECK(ndr_push_align(ndr, 5));
17380                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17381                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17382                         break; }
17383
17384                         default: {
17385                         break; }
17386
17387                 }
17388         }
17389         if (ndr_flags & NDR_BUFFERS) {
17390                 int level = ndr_push_get_switch_value(ndr, r);
17391                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17392                 switch (level) {
17393                         case 1:
17394                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17395                         break;
17396
17397                         default:
17398                         break;
17399
17400                 }
17401         }
17402         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17403         return NDR_ERR_SUCCESS;
17404 }
17405
17406 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
17407 {
17408         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17409         int level;
17410         level = ndr_pull_get_switch_value(ndr, r);
17411         if (ndr_flags & NDR_SCALARS) {
17412                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17413                 switch (level) {
17414                         case 1: {
17415                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17416                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17417                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17418                         break; }
17419
17420                         default: {
17421                         break; }
17422
17423                 }
17424         }
17425         if (ndr_flags & NDR_BUFFERS) {
17426                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17427                 switch (level) {
17428                         case 1:
17429                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17430                         break;
17431
17432                         default:
17433                         break;
17434
17435                 }
17436         }
17437         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17438         return NDR_ERR_SUCCESS;
17439 }
17440
17441 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
17442 {
17443         int level;
17444         level = ndr_print_get_switch_value(ndr, r);
17445         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
17446         switch (level) {
17447                 case 1:
17448                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
17449                 break;
17450
17451                 default:
17452                 break;
17453
17454         }
17455 }
17456
17457 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17458 {
17459         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17460         return NDR_ERR_SUCCESS;
17461 }
17462
17463 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17464 {
17465         uint32_t v;
17466         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17467         *r = v;
17468         return NDR_ERR_SUCCESS;
17469 }
17470
17471 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17472 {
17473         ndr_print_uint32(ndr, name, r);
17474         ndr->depth++;
17475         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
17476         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
17477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
17478         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
17479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
17480         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
17481         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
17482         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
17483         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
17484         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
17485         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
17486         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
17487         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
17488         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
17489         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
17490         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
17491         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
17492         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
17493         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
17494         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
17495         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
17496         ndr->depth--;
17497 }
17498
17499 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
17500 {
17501         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
17502         return NDR_ERR_SUCCESS;
17503 }
17504
17505 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
17506 {
17507         uint16_t v;
17508         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
17509         *r = v;
17510         return NDR_ERR_SUCCESS;
17511 }
17512
17513 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
17514 {
17515         const char *val = NULL;
17516
17517         switch (r) {
17518                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
17519                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
17520                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
17521                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
17522                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
17523                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
17524                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17525                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
17526                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
17527                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
17528                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
17529                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
17530                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17531                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
17532                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
17533                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
17534                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
17535                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
17536                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
17537                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
17538                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
17539                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
17540                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
17541                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
17542         }
17543         ndr_print_enum(ndr, name, "ENUM", val, r);
17544 }
17545
17546 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
17547 {
17548         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
17549         return NDR_ERR_SUCCESS;
17550 }
17551
17552 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
17553 {
17554         uint16_t v;
17555         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
17556         *r = v;
17557         return NDR_ERR_SUCCESS;
17558 }
17559
17560 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
17561 {
17562         const char *val = NULL;
17563
17564         switch (r) {
17565                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
17566                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
17567                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
17568                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
17569                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
17570                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
17571                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
17572                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
17573                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
17574                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17575                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
17576                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
17577                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17578                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
17579                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
17580                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
17581                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
17582                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
17583                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
17584                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
17585                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
17586                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
17587                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
17588                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
17589                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
17590                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
17591                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
17592                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
17593         }
17594         ndr_print_enum(ndr, name, "ENUM", val, r);
17595 }
17596
17597 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17598 {
17599         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
17600         return NDR_ERR_SUCCESS;
17601 }
17602
17603 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17604 {
17605         uint16_t v;
17606         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
17607         *r = v;
17608         return NDR_ERR_SUCCESS;
17609 }
17610
17611 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17612 {
17613         const char *val = NULL;
17614
17615         switch (r) {
17616                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17617                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17618         }
17619         ndr_print_enum(ndr, name, "ENUM", val, r);
17620 }
17621
17622 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
17623 {
17624         if (ndr_flags & NDR_SCALARS) {
17625                 int level = ndr_push_get_switch_value(ndr, r);
17626                 NDR_CHECK(ndr_push_union_align(ndr, 2));
17627                 switch (level) {
17628                         case PRINTER_NOTIFY_TYPE: {
17629                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17630                         break; }
17631
17632                         case JOB_NOTIFY_TYPE: {
17633                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17634                         break; }
17635
17636                         default: {
17637                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17638                         break; }
17639
17640                 }
17641         }
17642         if (ndr_flags & NDR_BUFFERS) {
17643                 int level = ndr_push_get_switch_value(ndr, r);
17644                 switch (level) {
17645                         case PRINTER_NOTIFY_TYPE:
17646                         break;
17647
17648                         case JOB_NOTIFY_TYPE:
17649                         break;
17650
17651                         default:
17652                         break;
17653
17654                 }
17655         }
17656         return NDR_ERR_SUCCESS;
17657 }
17658
17659 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
17660 {
17661         int level;
17662         level = ndr_pull_get_switch_value(ndr, r);
17663         if (ndr_flags & NDR_SCALARS) {
17664                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
17665                 switch (level) {
17666                         case PRINTER_NOTIFY_TYPE: {
17667                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17668                         break; }
17669
17670                         case JOB_NOTIFY_TYPE: {
17671                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17672                         break; }
17673
17674                         default: {
17675                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17676                         break; }
17677
17678                 }
17679         }
17680         if (ndr_flags & NDR_BUFFERS) {
17681                 switch (level) {
17682                         case PRINTER_NOTIFY_TYPE:
17683                         break;
17684
17685                         case JOB_NOTIFY_TYPE:
17686                         break;
17687
17688                         default:
17689                         break;
17690
17691                 }
17692         }
17693         return NDR_ERR_SUCCESS;
17694 }
17695
17696 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17697 {
17698         uint32_t cntr_fields_1;
17699         if (ndr_flags & NDR_SCALARS) {
17700                 NDR_CHECK(ndr_push_align(ndr, 5));
17701                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17702                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17707         }
17708         if (ndr_flags & NDR_BUFFERS) {
17709                 if (r->fields) {
17710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
17711                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17712                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17713                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17714                         }
17715                 }
17716         }
17717         return NDR_ERR_SUCCESS;
17718 }
17719
17720 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17721 {
17722         uint32_t _ptr_fields;
17723         uint32_t cntr_fields_1;
17724         TALLOC_CTX *_mem_save_fields_0;
17725         TALLOC_CTX *_mem_save_fields_1;
17726         if (ndr_flags & NDR_SCALARS) {
17727                 NDR_CHECK(ndr_pull_align(ndr, 5));
17728                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17729                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17734                 if (_ptr_fields) {
17735                         NDR_PULL_ALLOC(ndr, r->fields);
17736                 } else {
17737                         r->fields = NULL;
17738                 }
17739         }
17740         if (ndr_flags & NDR_BUFFERS) {
17741                 if (r->fields) {
17742                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17743                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17744                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17745                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17746                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17747                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17748                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17749                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17750                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17751                         }
17752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17754                 }
17755                 if (r->fields) {
17756                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17757                 }
17758         }
17759         return NDR_ERR_SUCCESS;
17760 }
17761
17762 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17763 {
17764         uint32_t cntr_fields_1;
17765         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17766         ndr->depth++;
17767         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17768         ndr_print_uint16(ndr, "u1", r->u1);
17769         ndr_print_uint32(ndr, "u2", r->u2);
17770         ndr_print_uint32(ndr, "u3", r->u3);
17771         ndr_print_uint32(ndr, "count", r->count);
17772         ndr_print_ptr(ndr, "fields", r->fields);
17773         ndr->depth++;
17774         if (r->fields) {
17775                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17776                 ndr->depth++;
17777                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17778                         char *idx_1=NULL;
17779                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17780                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
17781                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
17782                                 free(idx_1);
17783                         }
17784                 }
17785                 ndr->depth--;
17786         }
17787         ndr->depth--;
17788         ndr->depth--;
17789 }
17790
17791 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17792 {
17793         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17794         return NDR_ERR_SUCCESS;
17795 }
17796
17797 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17798 {
17799         uint32_t v;
17800         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17801         *r = v;
17802         return NDR_ERR_SUCCESS;
17803 }
17804
17805 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17806 {
17807         ndr_print_uint32(ndr, name, r);
17808         ndr->depth++;
17809         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17810         ndr->depth--;
17811 }
17812
17813 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17814 {
17815         uint32_t cntr_types_1;
17816         if (ndr_flags & NDR_SCALARS) {
17817                 NDR_CHECK(ndr_push_align(ndr, 5));
17818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17819                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17821                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17822         }
17823         if (ndr_flags & NDR_BUFFERS) {
17824                 if (r->types) {
17825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
17826                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17827                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17828                         }
17829                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17830                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17831                         }
17832                 }
17833         }
17834         return NDR_ERR_SUCCESS;
17835 }
17836
17837 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17838 {
17839         uint32_t _ptr_types;
17840         uint32_t cntr_types_1;
17841         TALLOC_CTX *_mem_save_types_0;
17842         TALLOC_CTX *_mem_save_types_1;
17843         if (ndr_flags & NDR_SCALARS) {
17844                 NDR_CHECK(ndr_pull_align(ndr, 5));
17845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17846                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17849                 if (_ptr_types) {
17850                         NDR_PULL_ALLOC(ndr, r->types);
17851                 } else {
17852                         r->types = NULL;
17853                 }
17854         }
17855         if (ndr_flags & NDR_BUFFERS) {
17856                 if (r->types) {
17857                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17858                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17859                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17860                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17861                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17862                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17863                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17864                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17865                         }
17866                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17867                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17868                         }
17869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17871                 }
17872                 if (r->types) {
17873                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17874                 }
17875         }
17876         return NDR_ERR_SUCCESS;
17877 }
17878
17879 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17880 {
17881         uint32_t cntr_types_1;
17882         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17883         ndr->depth++;
17884         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17885         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17886         ndr_print_uint32(ndr, "count", r->count);
17887         ndr_print_ptr(ndr, "types", r->types);
17888         ndr->depth++;
17889         if (r->types) {
17890                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17891                 ndr->depth++;
17892                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17893                         char *idx_1=NULL;
17894                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17895                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17896                                 free(idx_1);
17897                         }
17898                 }
17899                 ndr->depth--;
17900         }
17901         ndr->depth--;
17902         ndr->depth--;
17903 }
17904
17905 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17906 {
17907         if (ndr_flags & NDR_SCALARS) {
17908                 NDR_CHECK(ndr_push_align(ndr, 5));
17909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17911         }
17912         if (ndr_flags & NDR_BUFFERS) {
17913                 if (r->string) {
17914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
17915                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17916                 }
17917         }
17918         return NDR_ERR_SUCCESS;
17919 }
17920
17921 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17922 {
17923         uint32_t _ptr_string;
17924         TALLOC_CTX *_mem_save_string_0;
17925         if (ndr_flags & NDR_SCALARS) {
17926                 NDR_CHECK(ndr_pull_align(ndr, 5));
17927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17929                 if (_ptr_string) {
17930                         NDR_PULL_ALLOC(ndr, r->string);
17931                 } else {
17932                         r->string = NULL;
17933                 }
17934         }
17935         if (ndr_flags & NDR_BUFFERS) {
17936                 if (r->string) {
17937                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17938                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17940                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17942                 }
17943                 if (r->string) {
17944                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17945                 }
17946         }
17947         return NDR_ERR_SUCCESS;
17948 }
17949
17950 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17951 {
17952         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17953         ndr->depth++;
17954         ndr_print_uint32(ndr, "size", r->size);
17955         ndr_print_ptr(ndr, "string", r->string);
17956         ndr->depth++;
17957         if (r->string) {
17958                 ndr_print_string(ndr, "string", r->string);
17959         }
17960         ndr->depth--;
17961         ndr->depth--;
17962 }
17963
17964 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17965 {
17966         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17967         return NDR_ERR_SUCCESS;
17968 }
17969
17970 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17971 {
17972         uint32_t v;
17973         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17974         *r = v;
17975         return NDR_ERR_SUCCESS;
17976 }
17977
17978 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17979 {
17980         const char *val = NULL;
17981
17982         switch (r) {
17983                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17984                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17985                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17986                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17987                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17988         }
17989         ndr_print_enum(ndr, name, "ENUM", val, r);
17990 }
17991
17992 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17993 {
17994         if (ndr_flags & NDR_SCALARS) {
17995                 int level = ndr_push_get_switch_value(ndr, r);
17996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17997                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17998                 switch (level) {
17999                         case 1: {
18000                                 uint32_t cntr_integer_0;
18001                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18002                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18003                                 }
18004                         break; }
18005
18006                         case 2: {
18007                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18008                         break; }
18009
18010                         case 3: {
18011                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18012                         break; }
18013
18014                         case 4: {
18015                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18016                         break; }
18017
18018                         case 5: {
18019                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18020                         break; }
18021
18022                         default:
18023                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18024                 }
18025         }
18026         if (ndr_flags & NDR_BUFFERS) {
18027                 int level = ndr_push_get_switch_value(ndr, r);
18028                 switch (level) {
18029                         case 1:
18030                         break;
18031
18032                         case 2:
18033                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18034                         break;
18035
18036                         case 3:
18037                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18038                         break;
18039
18040                         case 4:
18041                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18042                         break;
18043
18044                         case 5:
18045                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18046                         break;
18047
18048                         default:
18049                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18050                 }
18051         }
18052         return NDR_ERR_SUCCESS;
18053 }
18054
18055 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18056 {
18057         int level;
18058         uint32_t _level;
18059         level = ndr_pull_get_switch_value(ndr, r);
18060         if (ndr_flags & NDR_SCALARS) {
18061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18062                 if (_level != level) {
18063                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18064                 }
18065                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18066                 switch (level) {
18067                         case 1: {
18068                                 uint32_t cntr_integer_0;
18069                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18070                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18071                                 }
18072                         break; }
18073
18074                         case 2: {
18075                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18076                         break; }
18077
18078                         case 3: {
18079                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18080                         break; }
18081
18082                         case 4: {
18083                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18084                         break; }
18085
18086                         case 5: {
18087                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18088                         break; }
18089
18090                         default:
18091                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18092                 }
18093         }
18094         if (ndr_flags & NDR_BUFFERS) {
18095                 switch (level) {
18096                         case 1:
18097                         break;
18098
18099                         case 2:
18100                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18101                         break;
18102
18103                         case 3:
18104                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18105                         break;
18106
18107                         case 4:
18108                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18109                         break;
18110
18111                         case 5:
18112                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18113                         break;
18114
18115                         default:
18116                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18117                 }
18118         }
18119         return NDR_ERR_SUCCESS;
18120 }
18121
18122 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18123 {
18124         int level;
18125         uint32_t cntr_integer_0;
18126         level = ndr_print_get_switch_value(ndr, r);
18127         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18128         switch (level) {
18129                 case 1:
18130                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18131                         ndr->depth++;
18132                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18133                                 char *idx_0=NULL;
18134                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18135                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18136                                         free(idx_0);
18137                                 }
18138                         }
18139                         ndr->depth--;
18140                 break;
18141
18142                 case 2:
18143                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18144                 break;
18145
18146                 case 3:
18147                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18148                 break;
18149
18150                 case 4:
18151                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18152                 break;
18153
18154                 case 5:
18155                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18156                 break;
18157
18158                 default:
18159                         ndr_print_bad_level(ndr, name, level);
18160         }
18161 }
18162
18163 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18164 {
18165         if (ndr_flags & NDR_SCALARS) {
18166                 NDR_CHECK(ndr_push_align(ndr, 5));
18167                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18168                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18169                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18170                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18172                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18173                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18174         }
18175         if (ndr_flags & NDR_BUFFERS) {
18176                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18177         }
18178         return NDR_ERR_SUCCESS;
18179 }
18180
18181 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18182 {
18183         if (ndr_flags & NDR_SCALARS) {
18184                 NDR_CHECK(ndr_pull_align(ndr, 5));
18185                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18186                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18187                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18188                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18190                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18191                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18192         }
18193         if (ndr_flags & NDR_BUFFERS) {
18194                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18195         }
18196         return NDR_ERR_SUCCESS;
18197 }
18198
18199 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18200 {
18201         ndr_print_struct(ndr, name, "spoolss_Notify");
18202         ndr->depth++;
18203         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18204         ndr_print_set_switch_value(ndr, &r->field, r->type);
18205         ndr_print_spoolss_Field(ndr, "field", &r->field);
18206         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18207         ndr_print_uint32(ndr, "job_id", r->job_id);
18208         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18209         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18210         ndr->depth--;
18211 }
18212
18213 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18214 {
18215         uint32_t cntr_notifies_0;
18216         if (ndr_flags & NDR_SCALARS) {
18217                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18218                 NDR_CHECK(ndr_push_align(ndr, 5));
18219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18222                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18223                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18224                 }
18225         }
18226         if (ndr_flags & NDR_BUFFERS) {
18227                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18228                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18229                 }
18230         }
18231         return NDR_ERR_SUCCESS;
18232 }
18233
18234 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
18235 {
18236         uint32_t cntr_notifies_0;
18237         TALLOC_CTX *_mem_save_notifies_0;
18238         if (ndr_flags & NDR_SCALARS) {
18239                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
18240                 NDR_CHECK(ndr_pull_align(ndr, 5));
18241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18242                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18244                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
18245                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18246                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18247                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18248                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18249                 }
18250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18251                 if (r->notifies) {
18252                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
18253                 }
18254         }
18255         if (ndr_flags & NDR_BUFFERS) {
18256                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18257                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18258                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18259                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18260                 }
18261                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18262         }
18263         return NDR_ERR_SUCCESS;
18264 }
18265
18266 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
18267 {
18268         uint32_t cntr_notifies_0;
18269         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
18270         ndr->depth++;
18271         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18272         ndr_print_uint32(ndr, "flags", r->flags);
18273         ndr_print_uint32(ndr, "count", r->count);
18274         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
18275         ndr->depth++;
18276         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
18277                 char *idx_0=NULL;
18278                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
18279                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
18280                         free(idx_0);
18281                 }
18282         }
18283         ndr->depth--;
18284         ndr->depth--;
18285 }
18286
18287 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
18288 {
18289         if (ndr_flags & NDR_SCALARS) {
18290                 int level = ndr_push_get_switch_value(ndr, r);
18291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18292                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18293                 switch (level) {
18294                         case 0: {
18295                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
18296                         break; }
18297
18298                         default:
18299                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18300                 }
18301         }
18302         if (ndr_flags & NDR_BUFFERS) {
18303                 int level = ndr_push_get_switch_value(ndr, r);
18304                 switch (level) {
18305                         case 0:
18306                                 if (r->info0) {
18307                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18308                                 }
18309                         break;
18310
18311                         default:
18312                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18313                 }
18314         }
18315         return NDR_ERR_SUCCESS;
18316 }
18317
18318 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
18319 {
18320         int level;
18321         uint32_t _level;
18322         TALLOC_CTX *_mem_save_info0_0;
18323         level = ndr_pull_get_switch_value(ndr, r);
18324         if (ndr_flags & NDR_SCALARS) {
18325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18326                 if (_level != level) {
18327                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18328                 }
18329                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18330                 switch (level) {
18331                         case 0: {
18332                                 uint32_t _ptr_info0;
18333                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
18334                                 if (_ptr_info0) {
18335                                         NDR_PULL_ALLOC(ndr, r->info0);
18336                                 } else {
18337                                         r->info0 = NULL;
18338                                 }
18339                         break; }
18340
18341                         default:
18342                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18343                 }
18344         }
18345         if (ndr_flags & NDR_BUFFERS) {
18346                 switch (level) {
18347                         case 0:
18348                                 if (r->info0) {
18349                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18350                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
18351                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18352                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
18353                                 }
18354                         break;
18355
18356                         default:
18357                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18358                 }
18359         }
18360         return NDR_ERR_SUCCESS;
18361 }
18362
18363 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
18364 {
18365         int level;
18366         level = ndr_print_get_switch_value(ndr, r);
18367         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
18368         switch (level) {
18369                 case 0:
18370                         ndr_print_ptr(ndr, "info0", r->info0);
18371                         ndr->depth++;
18372                         if (r->info0) {
18373                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
18374                         }
18375                         ndr->depth--;
18376                 break;
18377
18378                 default:
18379                         ndr_print_bad_level(ndr, name, level);
18380         }
18381 }
18382
18383 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(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_PrinterNotifyFlags(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_PrinterNotifyFlags(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), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
18402         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
18403         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
18404         ndr->depth--;
18405 }
18406
18407 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
18408 {
18409         if (ndr_flags & NDR_SCALARS) {
18410                 NDR_CHECK(ndr_push_align(ndr, 5));
18411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18415                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18416                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18417                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18418         }
18419         if (ndr_flags & NDR_BUFFERS) {
18420                 if (r->client) {
18421                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18424                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18425                 }
18426                 if (r->user) {
18427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18430                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18431                 }
18432         }
18433         return NDR_ERR_SUCCESS;
18434 }
18435
18436 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
18437 {
18438         uint32_t _ptr_client;
18439         TALLOC_CTX *_mem_save_client_0;
18440         uint32_t _ptr_user;
18441         TALLOC_CTX *_mem_save_user_0;
18442         if (ndr_flags & NDR_SCALARS) {
18443                 NDR_CHECK(ndr_pull_align(ndr, 5));
18444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18446                 if (_ptr_client) {
18447                         NDR_PULL_ALLOC(ndr, r->client);
18448                 } else {
18449                         r->client = NULL;
18450                 }
18451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18452                 if (_ptr_user) {
18453                         NDR_PULL_ALLOC(ndr, r->user);
18454                 } else {
18455                         r->user = NULL;
18456                 }
18457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18458                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18459                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18460                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18461         }
18462         if (ndr_flags & NDR_BUFFERS) {
18463                 if (r->client) {
18464                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18465                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18466                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18467                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18468                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18469                                 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));
18470                         }
18471                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18472                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18474                 }
18475                 if (r->user) {
18476                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18477                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18478                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18479                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18480                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18481                                 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));
18482                         }
18483                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18484                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18486                 }
18487         }
18488         return NDR_ERR_SUCCESS;
18489 }
18490
18491 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
18492 {
18493         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
18494         ndr->depth++;
18495         ndr_print_uint32(ndr, "size", r->size);
18496         ndr_print_ptr(ndr, "client", r->client);
18497         ndr->depth++;
18498         if (r->client) {
18499                 ndr_print_string(ndr, "client", r->client);
18500         }
18501         ndr->depth--;
18502         ndr_print_ptr(ndr, "user", r->user);
18503         ndr->depth++;
18504         if (r->user) {
18505                 ndr_print_string(ndr, "user", r->user);
18506         }
18507         ndr->depth--;
18508         ndr_print_uint32(ndr, "build", r->build);
18509         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18510         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18511         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18512         ndr->depth--;
18513 }
18514
18515 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
18516 {
18517         if (ndr_flags & NDR_SCALARS) {
18518                 NDR_CHECK(ndr_push_align(ndr, 4));
18519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
18520         }
18521         if (ndr_flags & NDR_BUFFERS) {
18522         }
18523         return NDR_ERR_SUCCESS;
18524 }
18525
18526 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
18527 {
18528         if (ndr_flags & NDR_SCALARS) {
18529                 NDR_CHECK(ndr_pull_align(ndr, 4));
18530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
18531         }
18532         if (ndr_flags & NDR_BUFFERS) {
18533         }
18534         return NDR_ERR_SUCCESS;
18535 }
18536
18537 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
18538 {
18539         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
18540         ndr->depth++;
18541         ndr_print_uint32(ndr, "not_used", r->not_used);
18542         ndr->depth--;
18543 }
18544
18545 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
18546 {
18547         if (ndr_flags & NDR_SCALARS) {
18548                 NDR_CHECK(ndr_push_align(ndr, 5));
18549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
18552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18555                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18556                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18557                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18558                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
18559         }
18560         if (ndr_flags & NDR_BUFFERS) {
18561                 if (r->client) {
18562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18563                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18564                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18565                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18566                 }
18567                 if (r->user) {
18568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18569                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18571                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18572                 }
18573         }
18574         return NDR_ERR_SUCCESS;
18575 }
18576
18577 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
18578 {
18579         uint32_t _ptr_client;
18580         TALLOC_CTX *_mem_save_client_0;
18581         uint32_t _ptr_user;
18582         TALLOC_CTX *_mem_save_user_0;
18583         if (ndr_flags & NDR_SCALARS) {
18584                 NDR_CHECK(ndr_pull_align(ndr, 5));
18585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
18588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18589                 if (_ptr_client) {
18590                         NDR_PULL_ALLOC(ndr, r->client);
18591                 } else {
18592                         r->client = NULL;
18593                 }
18594                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18595                 if (_ptr_user) {
18596                         NDR_PULL_ALLOC(ndr, r->user);
18597                 } else {
18598                         r->user = NULL;
18599                 }
18600                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18601                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18602                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18603                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18604                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
18605         }
18606         if (ndr_flags & NDR_BUFFERS) {
18607                 if (r->client) {
18608                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18609                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18610                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18611                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18612                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18613                                 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));
18614                         }
18615                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18616                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18618                 }
18619                 if (r->user) {
18620                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18621                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18622                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18623                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18624                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18625                                 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));
18626                         }
18627                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18628                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18630                 }
18631         }
18632         return NDR_ERR_SUCCESS;
18633 }
18634
18635 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
18636 {
18637         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
18638         ndr->depth++;
18639         ndr_print_uint32(ndr, "size", r->size);
18640         ndr_print_uint32(ndr, "flags", r->flags);
18641         ndr_print_uint32(ndr, "size2", r->size2);
18642         ndr_print_ptr(ndr, "client", r->client);
18643         ndr->depth++;
18644         if (r->client) {
18645                 ndr_print_string(ndr, "client", r->client);
18646         }
18647         ndr->depth--;
18648         ndr_print_ptr(ndr, "user", r->user);
18649         ndr->depth++;
18650         if (r->user) {
18651                 ndr_print_string(ndr, "user", r->user);
18652         }
18653         ndr->depth--;
18654         ndr_print_uint32(ndr, "build", r->build);
18655         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18656         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18657         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18658         ndr_print_udlong(ndr, "reserved", r->reserved);
18659         ndr->depth--;
18660 }
18661
18662 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18663 {
18664         if (ndr_flags & NDR_SCALARS) {
18665                 int level = ndr_push_get_switch_value(ndr, r);
18666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18667                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18668                 switch (level) {
18669                         case 1: {
18670                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18671                         break; }
18672
18673                         case 2: {
18674                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18675                         break; }
18676
18677                         case 3: {
18678                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18679                         break; }
18680
18681                         default:
18682                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18683                 }
18684         }
18685         if (ndr_flags & NDR_BUFFERS) {
18686                 int level = ndr_push_get_switch_value(ndr, r);
18687                 switch (level) {
18688                         case 1:
18689                                 if (r->level1) {
18690                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18691                                 }
18692                         break;
18693
18694                         case 2:
18695                                 if (r->level2) {
18696                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18697                                 }
18698                         break;
18699
18700                         case 3:
18701                                 if (r->level3) {
18702                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18703                                 }
18704                         break;
18705
18706                         default:
18707                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18708                 }
18709         }
18710         return NDR_ERR_SUCCESS;
18711 }
18712
18713 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18714 {
18715         int level;
18716         uint32_t _level;
18717         TALLOC_CTX *_mem_save_level1_0;
18718         TALLOC_CTX *_mem_save_level2_0;
18719         TALLOC_CTX *_mem_save_level3_0;
18720         level = ndr_pull_get_switch_value(ndr, r);
18721         if (ndr_flags & NDR_SCALARS) {
18722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18723                 if (_level != level) {
18724                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18725                 }
18726                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18727                 switch (level) {
18728                         case 1: {
18729                                 uint32_t _ptr_level1;
18730                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18731                                 if (_ptr_level1) {
18732                                         NDR_PULL_ALLOC(ndr, r->level1);
18733                                 } else {
18734                                         r->level1 = NULL;
18735                                 }
18736                         break; }
18737
18738                         case 2: {
18739                                 uint32_t _ptr_level2;
18740                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18741                                 if (_ptr_level2) {
18742                                         NDR_PULL_ALLOC(ndr, r->level2);
18743                                 } else {
18744                                         r->level2 = NULL;
18745                                 }
18746                         break; }
18747
18748                         case 3: {
18749                                 uint32_t _ptr_level3;
18750                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18751                                 if (_ptr_level3) {
18752                                         NDR_PULL_ALLOC(ndr, r->level3);
18753                                 } else {
18754                                         r->level3 = NULL;
18755                                 }
18756                         break; }
18757
18758                         default:
18759                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18760                 }
18761         }
18762         if (ndr_flags & NDR_BUFFERS) {
18763                 switch (level) {
18764                         case 1:
18765                                 if (r->level1) {
18766                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18767                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18768                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18769                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18770                                 }
18771                         break;
18772
18773                         case 2:
18774                                 if (r->level2) {
18775                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18776                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18777                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18778                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18779                                 }
18780                         break;
18781
18782                         case 3:
18783                                 if (r->level3) {
18784                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18785                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18786                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18787                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18788                                 }
18789                         break;
18790
18791                         default:
18792                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18793                 }
18794         }
18795         return NDR_ERR_SUCCESS;
18796 }
18797
18798 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18799 {
18800         int level;
18801         level = ndr_print_get_switch_value(ndr, r);
18802         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18803         switch (level) {
18804                 case 1:
18805                         ndr_print_ptr(ndr, "level1", r->level1);
18806                         ndr->depth++;
18807                         if (r->level1) {
18808                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18809                         }
18810                         ndr->depth--;
18811                 break;
18812
18813                 case 2:
18814                         ndr_print_ptr(ndr, "level2", r->level2);
18815                         ndr->depth++;
18816                         if (r->level2) {
18817                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18818                         }
18819                         ndr->depth--;
18820                 break;
18821
18822                 case 3:
18823                         ndr_print_ptr(ndr, "level3", r->level3);
18824                         ndr->depth++;
18825                         if (r->level3) {
18826                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18827                         }
18828                         ndr->depth--;
18829                 break;
18830
18831                 default:
18832                         ndr_print_bad_level(ndr, name, level);
18833         }
18834 }
18835
18836 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18837 {
18838         if (ndr_flags & NDR_SCALARS) {
18839                 NDR_CHECK(ndr_push_align(ndr, 5));
18840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18841                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18842                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18843         }
18844         if (ndr_flags & NDR_BUFFERS) {
18845                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18846         }
18847         return NDR_ERR_SUCCESS;
18848 }
18849
18850 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18851 {
18852         if (ndr_flags & NDR_SCALARS) {
18853                 NDR_CHECK(ndr_pull_align(ndr, 5));
18854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18855                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18856                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18857         }
18858         if (ndr_flags & NDR_BUFFERS) {
18859                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18860         }
18861         return NDR_ERR_SUCCESS;
18862 }
18863
18864 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18865 {
18866         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18867         ndr->depth++;
18868         ndr_print_uint32(ndr, "level", r->level);
18869         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18870         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18871         ndr->depth--;
18872 }
18873
18874 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18875 {
18876         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18877         return NDR_ERR_SUCCESS;
18878 }
18879
18880 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18881 {
18882         uint32_t v;
18883         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18884         *r = v;
18885         return NDR_ERR_SUCCESS;
18886 }
18887
18888 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18889 {
18890         ndr_print_uint32(ndr, name, r);
18891         ndr->depth++;
18892         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18893         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18894         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18895         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18896         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18897         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18898         ndr->depth--;
18899 }
18900
18901 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
18902 {
18903         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18904         if (ndr_flags & NDR_SCALARS) {
18905                 NDR_CHECK(ndr_push_align(ndr, 5));
18906                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18907                 {
18908                         uint32_t _flags_save_string = ndr->flags;
18909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18910                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
18911                         ndr->flags = _flags_save_string;
18912                 }
18913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
18914                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
18915                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
18916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
18917         }
18918         if (ndr_flags & NDR_BUFFERS) {
18919                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18920                 {
18921                         uint32_t _flags_save_string = ndr->flags;
18922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18923                         if (r->value_name) {
18924                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
18925                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
18926                         }
18927                         ndr->flags = _flags_save_string;
18928                 }
18929                 if (r->data) {
18930                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
18931                         {
18932                                 struct ndr_push *_ndr_data;
18933                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18934                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
18935                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18936                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18937                         }
18938                 }
18939         }
18940         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18941         return NDR_ERR_SUCCESS;
18942 }
18943
18944 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
18945 {
18946         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18947         uint32_t _ptr_value_name;
18948         TALLOC_CTX *_mem_save_value_name_0;
18949         uint32_t _ptr_data;
18950         TALLOC_CTX *_mem_save_data_0;
18951         if (ndr_flags & NDR_SCALARS) {
18952                 NDR_CHECK(ndr_pull_align(ndr, 5));
18953                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18954                 {
18955                         uint32_t _flags_save_string = ndr->flags;
18956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18957                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
18958                         if (_ptr_value_name) {
18959                                 NDR_PULL_ALLOC(ndr, r->value_name);
18960                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
18961                         } else {
18962                                 r->value_name = NULL;
18963                         }
18964                         ndr->flags = _flags_save_string;
18965                 }
18966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
18967                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
18968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
18969                 if (_ptr_data) {
18970                         NDR_PULL_ALLOC(ndr, r->data);
18971                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
18972                 } else {
18973                         r->data = NULL;
18974                 }
18975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
18976         }
18977         if (ndr_flags & NDR_BUFFERS) {
18978                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18979                 {
18980                         uint32_t _flags_save_string = ndr->flags;
18981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18982                         if (r->value_name) {
18983                                 uint32_t _relative_save_offset;
18984                                 _relative_save_offset = ndr->offset;
18985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
18986                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18987                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
18988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
18989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
18990                                 ndr->offset = _relative_save_offset;
18991                         }
18992                         ndr->flags = _flags_save_string;
18993                 }
18994                 if (r->data) {
18995                         uint32_t _relative_save_offset;
18996                         _relative_save_offset = ndr->offset;
18997                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
18998                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
18999                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19000                         {
19001                                 struct ndr_pull *_ndr_data;
19002                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19003                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
19004                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19005                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19006                         }
19007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19008                         ndr->offset = _relative_save_offset;
19009                 }
19010         }
19011         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19012         return NDR_ERR_SUCCESS;
19013 }
19014
19015 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19016 {
19017         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19018         ndr->depth++;
19019         ndr_print_ptr(ndr, "value_name", r->value_name);
19020         ndr->depth++;
19021         if (r->value_name) {
19022                 ndr_print_string(ndr, "value_name", r->value_name);
19023         }
19024         ndr->depth--;
19025         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19026         ndr_print_winreg_Type(ndr, "type", r->type);
19027         ndr_print_ptr(ndr, "data", r->data);
19028         ndr->depth++;
19029         if (r->data) {
19030                 ndr_print_set_switch_value(ndr, r->data, r->type);
19031                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19032         }
19033         ndr->depth--;
19034         ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags):r->data_length);
19035         ndr->depth--;
19036 }
19037
19038 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19039 {
19040         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19041 }
19042
19043 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19044 {
19045         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19046         return NDR_ERR_SUCCESS;
19047 }
19048
19049 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19050 {
19051         uint32_t v;
19052         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19053         *r = v;
19054         return NDR_ERR_SUCCESS;
19055 }
19056
19057 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19058 {
19059         ndr_print_uint32(ndr, name, r);
19060         ndr->depth++;
19061         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19062         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19063         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19064         ndr->depth--;
19065 }
19066
19067 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19068 {
19069         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19070         return NDR_ERR_SUCCESS;
19071 }
19072
19073 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19074 {
19075         uint32_t v;
19076         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19077         *r = v;
19078         return NDR_ERR_SUCCESS;
19079 }
19080
19081 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19082 {
19083         const char *val = NULL;
19084
19085         switch (r) {
19086                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19087                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19088         }
19089         ndr_print_enum(ndr, name, "ENUM", val, r);
19090 }
19091
19092 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19093 {
19094         if (ndr_flags & NDR_SCALARS) {
19095                 NDR_CHECK(ndr_push_align(ndr, 4));
19096                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19098                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19101                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19102                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19104                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19105                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19106                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19107                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19111         }
19112         if (ndr_flags & NDR_BUFFERS) {
19113         }
19114         return NDR_ERR_SUCCESS;
19115 }
19116
19117 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
19118 {
19119         if (ndr_flags & NDR_SCALARS) {
19120                 NDR_CHECK(ndr_pull_align(ndr, 4));
19121                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19123                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19126                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19127                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19129                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19130                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19131                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19132                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19136         }
19137         if (ndr_flags & NDR_BUFFERS) {
19138         }
19139         return NDR_ERR_SUCCESS;
19140 }
19141
19142 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
19143 {
19144         ndr_print_struct(ndr, name, "spoolss_PortData1");
19145         ndr->depth++;
19146         ndr_print_string(ndr, "portname", r->portname);
19147         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
19148         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19149         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19150         ndr_print_uint32(ndr, "reserved", r->reserved);
19151         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19152         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19153         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19154         ndr_print_string(ndr, "queue", r->queue);
19155         ndr_print_string(ndr, "ip_address", r->ip_address);
19156         ndr_print_string(ndr, "hardware_address", r->hardware_address);
19157         ndr_print_string(ndr, "device_type", r->device_type);
19158         ndr_print_uint32(ndr, "port_number", r->port_number);
19159         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19160         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19161         ndr->depth--;
19162 }
19163
19164 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
19165 {
19166         if (ndr_flags & NDR_SCALARS) {
19167                 NDR_CHECK(ndr_push_align(ndr, 4));
19168                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
19170                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19173                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19174                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19176                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19177                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
19182         }
19183         if (ndr_flags & NDR_BUFFERS) {
19184         }
19185         return NDR_ERR_SUCCESS;
19186 }
19187
19188 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
19189 {
19190         if (ndr_flags & NDR_SCALARS) {
19191                 NDR_CHECK(ndr_pull_align(ndr, 4));
19192                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19194                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19197                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19198                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19200                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19201                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
19206         }
19207         if (ndr_flags & NDR_BUFFERS) {
19208         }
19209         return NDR_ERR_SUCCESS;
19210 }
19211
19212 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
19213 {
19214         ndr_print_struct(ndr, name, "spoolss_PortData2");
19215         ndr->depth++;
19216         ndr_print_string(ndr, "portname", r->portname);
19217         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
19218         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19219         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19220         ndr_print_uint32(ndr, "reserved", r->reserved);
19221         ndr_print_string(ndr, "hostaddress", r->hostaddress);
19222         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19223         ndr_print_uint32(ndr, "dblspool", r->dblspool);
19224         ndr_print_string(ndr, "queue", r->queue);
19225         ndr_print_string(ndr, "device_type", r->device_type);
19226         ndr_print_uint32(ndr, "port_number", r->port_number);
19227         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19228         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19229         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
19230         ndr->depth--;
19231 }
19232
19233 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
19234 {
19235         if (ndr_flags & NDR_SCALARS) {
19236                 NDR_CHECK(ndr_push_align(ndr, 4));
19237                 {
19238                         uint32_t _flags_save_string = ndr->flags;
19239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19240                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
19241                         ndr->flags = _flags_save_string;
19242                 }
19243         }
19244         if (ndr_flags & NDR_BUFFERS) {
19245         }
19246         return NDR_ERR_SUCCESS;
19247 }
19248
19249 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
19250 {
19251         if (ndr_flags & NDR_SCALARS) {
19252                 NDR_CHECK(ndr_pull_align(ndr, 4));
19253                 {
19254                         uint32_t _flags_save_string = ndr->flags;
19255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19256                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
19257                         ndr->flags = _flags_save_string;
19258                 }
19259         }
19260         if (ndr_flags & NDR_BUFFERS) {
19261         }
19262         return NDR_ERR_SUCCESS;
19263 }
19264
19265 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
19266 {
19267         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
19268         ndr->depth++;
19269         ndr_print_string(ndr, "dll_name", r->dll_name);
19270         ndr->depth--;
19271 }
19272
19273 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19274 {
19275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19276         return NDR_ERR_SUCCESS;
19277 }
19278
19279 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19280 {
19281         uint32_t v;
19282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19283         *r = v;
19284         return NDR_ERR_SUCCESS;
19285 }
19286
19287 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19288 {
19289         ndr_print_uint32(ndr, name, r);
19290         ndr->depth++;
19291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
19292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
19293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
19294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
19295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
19296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
19297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
19298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
19299         ndr->depth--;
19300 }
19301
19302 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
19303 {
19304         if (ndr_flags & NDR_SCALARS) {
19305                 NDR_CHECK(ndr_push_align(ndr, 8));
19306                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19307                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
19308                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
19309                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
19310         }
19311         if (ndr_flags & NDR_BUFFERS) {
19312         }
19313         return NDR_ERR_SUCCESS;
19314 }
19315
19316 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
19317 {
19318         if (ndr_flags & NDR_SCALARS) {
19319                 NDR_CHECK(ndr_pull_align(ndr, 8));
19320                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
19321                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
19322                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
19323                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
19324         }
19325         if (ndr_flags & NDR_BUFFERS) {
19326         }
19327         return NDR_ERR_SUCCESS;
19328 }
19329
19330 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
19331 {
19332         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
19333         ndr->depth++;
19334         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
19335         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
19336         ndr_print_hyper(ndr, "driver_version", r->driver_version);
19337         ndr_print_string(ndr, "formname", r->formname);
19338         ndr->depth--;
19339 }
19340
19341 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
19342 {
19343         if (flags & NDR_IN) {
19344                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
19345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19346                 if (r->in.server) {
19347                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19348                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19349                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19350                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19351                 }
19352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19354                 if (r->in.buffer) {
19355                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19356                 }
19357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19358         }
19359         if (flags & NDR_OUT) {
19360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19361                 if (r->out.info) {
19362                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19363                 }
19364                 if (r->out.needed == NULL) {
19365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19366                 }
19367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19368                 if (r->out.count == NULL) {
19369                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19370                 }
19371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19372                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19373         }
19374         return NDR_ERR_SUCCESS;
19375 }
19376
19377 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
19378 {
19379         uint32_t _ptr_server;
19380         uint32_t _ptr_buffer;
19381         uint32_t _ptr_info;
19382         TALLOC_CTX *_mem_save_server_0;
19383         TALLOC_CTX *_mem_save_buffer_0;
19384         TALLOC_CTX *_mem_save_info_0;
19385         TALLOC_CTX *_mem_save_needed_0;
19386         TALLOC_CTX *_mem_save_count_0;
19387         if (flags & NDR_IN) {
19388                 ZERO_STRUCT(r->out);
19389
19390                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
19391                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19392                 if (_ptr_server) {
19393                         NDR_PULL_ALLOC(ndr, r->in.server);
19394                 } else {
19395                         r->in.server = NULL;
19396                 }
19397                 if (r->in.server) {
19398                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19399                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19400                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19401                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19402                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19403                                 return 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));
19404                         }
19405                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19406                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19408                 }
19409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19411                 if (_ptr_buffer) {
19412                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19413                 } else {
19414                         r->in.buffer = NULL;
19415                 }
19416                 if (r->in.buffer) {
19417                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19418                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19419                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19420                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19421                 }
19422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19423                 NDR_PULL_ALLOC(ndr, r->out.needed);
19424                 ZERO_STRUCTP(r->out.needed);
19425                 NDR_PULL_ALLOC(ndr, r->out.count);
19426                 ZERO_STRUCTP(r->out.count);
19427         }
19428         if (flags & NDR_OUT) {
19429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19430                 if (_ptr_info) {
19431                         NDR_PULL_ALLOC(ndr, r->out.info);
19432                 } else {
19433                         r->out.info = NULL;
19434                 }
19435                 if (r->out.info) {
19436                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19437                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19438                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19440                 }
19441                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19442                         NDR_PULL_ALLOC(ndr, r->out.needed);
19443                 }
19444                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19445                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19447                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19448                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19449                         NDR_PULL_ALLOC(ndr, r->out.count);
19450                 }
19451                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19452                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19455                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19456         }
19457         return NDR_ERR_SUCCESS;
19458 }
19459
19460 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
19461 {
19462         uint32_t cntr_info_0;
19463         if (flags & NDR_IN) {
19464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19466         }
19467         if (flags & NDR_OUT) {
19468                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19469                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19470                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19471                 }
19472                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19473                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19474                 }
19475         }
19476         return NDR_ERR_SUCCESS;
19477 }
19478
19479 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
19480 {
19481         uint32_t cntr_info_0;
19482         TALLOC_CTX *_mem_save_info_0;
19483         if (flags & NDR_IN) {
19484                 ZERO_STRUCT(r->out);
19485
19486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19488         }
19489         if (flags & NDR_OUT) {
19490                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19491                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19492                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19493                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19494                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19495                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19496                 }
19497                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19498                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19499                 }
19500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19501         }
19502         return NDR_ERR_SUCCESS;
19503 }
19504
19505 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
19506 {
19507         uint32_t cntr_info_2;
19508         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
19509         ndr->depth++;
19510         if (flags & NDR_SET_VALUES) {
19511                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19512         }
19513         if (flags & NDR_IN) {
19514                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
19515                 ndr->depth++;
19516                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
19517                 ndr_print_ptr(ndr, "server", r->in.server);
19518                 ndr->depth++;
19519                 if (r->in.server) {
19520                         ndr_print_string(ndr, "server", r->in.server);
19521                 }
19522                 ndr->depth--;
19523                 ndr_print_uint32(ndr, "level", r->in.level);
19524                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19525                 ndr->depth++;
19526                 if (r->in.buffer) {
19527                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19528                 }
19529                 ndr->depth--;
19530                 ndr_print_uint32(ndr, "offered", r->in.offered);
19531                 ndr->depth--;
19532         }
19533         if (flags & NDR_OUT) {
19534                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
19535                 ndr->depth++;
19536                 ndr_print_ptr(ndr, "count", r->out.count);
19537                 ndr->depth++;
19538                 ndr_print_uint32(ndr, "count", *r->out.count);
19539                 ndr->depth--;
19540                 ndr_print_ptr(ndr, "info", r->out.info);
19541                 ndr->depth++;
19542                 ndr_print_ptr(ndr, "info", *r->out.info);
19543                 ndr->depth++;
19544                 if (*r->out.info) {
19545                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19546                         ndr->depth++;
19547                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19548                                 char *idx_2=NULL;
19549                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19550                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19551                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19552                                         free(idx_2);
19553                                 }
19554                         }
19555                         ndr->depth--;
19556                 }
19557                 ndr->depth--;
19558                 ndr->depth--;
19559                 ndr_print_ptr(ndr, "needed", r->out.needed);
19560                 ndr->depth++;
19561                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19562                 ndr->depth--;
19563                 ndr_print_WERROR(ndr, "result", r->out.result);
19564                 ndr->depth--;
19565         }
19566         ndr->depth--;
19567 }
19568
19569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
19570 {
19571         if (flags & NDR_IN) {
19572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
19573                 if (r->in.printername) {
19574                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19575                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19576                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19577                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19578                 }
19579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
19580                 if (r->in.datatype) {
19581                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19582                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19583                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19584                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19585                 }
19586                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19587                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
19588         }
19589         if (flags & NDR_OUT) {
19590                 if (r->out.handle == NULL) {
19591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19592                 }
19593                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19594                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19595         }
19596         return NDR_ERR_SUCCESS;
19597 }
19598
19599 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
19600 {
19601         uint32_t _ptr_printername;
19602         uint32_t _ptr_datatype;
19603         TALLOC_CTX *_mem_save_printername_0;
19604         TALLOC_CTX *_mem_save_datatype_0;
19605         TALLOC_CTX *_mem_save_handle_0;
19606         if (flags & NDR_IN) {
19607                 ZERO_STRUCT(r->out);
19608
19609                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
19610                 if (_ptr_printername) {
19611                         NDR_PULL_ALLOC(ndr, r->in.printername);
19612                 } else {
19613                         r->in.printername = NULL;
19614                 }
19615                 if (r->in.printername) {
19616                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19617                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
19618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
19619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
19620                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
19621                                 return 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));
19622                         }
19623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
19624                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
19625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
19626                 }
19627                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
19628                 if (_ptr_datatype) {
19629                         NDR_PULL_ALLOC(ndr, r->in.datatype);
19630                 } else {
19631                         r->in.datatype = NULL;
19632                 }
19633                 if (r->in.datatype) {
19634                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
19635                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
19636                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
19637                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
19638                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
19639                                 return 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));
19640                         }
19641                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
19642                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
19643                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
19644                 }
19645                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19646                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
19647                 NDR_PULL_ALLOC(ndr, r->out.handle);
19648                 ZERO_STRUCTP(r->out.handle);
19649         }
19650         if (flags & NDR_OUT) {
19651                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19652                         NDR_PULL_ALLOC(ndr, r->out.handle);
19653                 }
19654                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19655                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19656                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19657                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19658                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19659         }
19660         return NDR_ERR_SUCCESS;
19661 }
19662
19663 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
19664 {
19665         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
19666         ndr->depth++;
19667         if (flags & NDR_SET_VALUES) {
19668                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19669         }
19670         if (flags & NDR_IN) {
19671                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
19672                 ndr->depth++;
19673                 ndr_print_ptr(ndr, "printername", r->in.printername);
19674                 ndr->depth++;
19675                 if (r->in.printername) {
19676                         ndr_print_string(ndr, "printername", r->in.printername);
19677                 }
19678                 ndr->depth--;
19679                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
19680                 ndr->depth++;
19681                 if (r->in.datatype) {
19682                         ndr_print_string(ndr, "datatype", r->in.datatype);
19683                 }
19684                 ndr->depth--;
19685                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
19686                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
19687                 ndr->depth--;
19688         }
19689         if (flags & NDR_OUT) {
19690                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
19691                 ndr->depth++;
19692                 ndr_print_ptr(ndr, "handle", r->out.handle);
19693                 ndr->depth++;
19694                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19695                 ndr->depth--;
19696                 ndr_print_WERROR(ndr, "result", r->out.result);
19697                 ndr->depth--;
19698         }
19699         ndr->depth--;
19700 }
19701
19702 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
19703 {
19704         if (flags & NDR_IN) {
19705                 if (r->in.handle == NULL) {
19706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19707                 }
19708                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19711                 if (r->in.ctr) {
19712                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19713                 }
19714                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19715         }
19716         if (flags & NDR_OUT) {
19717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19718         }
19719         return NDR_ERR_SUCCESS;
19720 }
19721
19722 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19723 {
19724         uint32_t _ptr_ctr;
19725         TALLOC_CTX *_mem_save_handle_0;
19726         TALLOC_CTX *_mem_save_ctr_0;
19727         if (flags & NDR_IN) {
19728                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19729                         NDR_PULL_ALLOC(ndr, r->in.handle);
19730                 }
19731                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19732                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19733                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19734                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19737                 if (_ptr_ctr) {
19738                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19739                 } else {
19740                         r->in.ctr = NULL;
19741                 }
19742                 if (r->in.ctr) {
19743                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19744                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
19745                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
19747                 }
19748                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
19749         }
19750         if (flags & NDR_OUT) {
19751                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19752         }
19753         return NDR_ERR_SUCCESS;
19754 }
19755
19756 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
19757 {
19758         ndr_print_struct(ndr, name, "spoolss_SetJob");
19759         ndr->depth++;
19760         if (flags & NDR_SET_VALUES) {
19761                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19762         }
19763         if (flags & NDR_IN) {
19764                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
19765                 ndr->depth++;
19766                 ndr_print_ptr(ndr, "handle", r->in.handle);
19767                 ndr->depth++;
19768                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19769                 ndr->depth--;
19770                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19771                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
19772                 ndr->depth++;
19773                 if (r->in.ctr) {
19774                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
19775                 }
19776                 ndr->depth--;
19777                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
19778                 ndr->depth--;
19779         }
19780         if (flags & NDR_OUT) {
19781                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
19782                 ndr->depth++;
19783                 ndr_print_WERROR(ndr, "result", r->out.result);
19784                 ndr->depth--;
19785         }
19786         ndr->depth--;
19787 }
19788
19789 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
19790 {
19791         if (flags & NDR_IN) {
19792                 if (r->in.handle == NULL) {
19793                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19794                 }
19795                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19799                 if (r->in.buffer) {
19800                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19801                 }
19802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19803         }
19804         if (flags & NDR_OUT) {
19805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19806                 if (r->out.info) {
19807                         {
19808                                 struct ndr_push *_ndr_info;
19809                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19810                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19811                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19812                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19813                         }
19814                 }
19815                 if (r->out.needed == NULL) {
19816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19817                 }
19818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19819                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19820         }
19821         return NDR_ERR_SUCCESS;
19822 }
19823
19824 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
19825 {
19826         uint32_t _ptr_buffer;
19827         uint32_t _ptr_info;
19828         TALLOC_CTX *_mem_save_handle_0;
19829         TALLOC_CTX *_mem_save_buffer_0;
19830         TALLOC_CTX *_mem_save_info_0;
19831         TALLOC_CTX *_mem_save_needed_0;
19832         if (flags & NDR_IN) {
19833                 ZERO_STRUCT(r->out);
19834
19835                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19836                         NDR_PULL_ALLOC(ndr, r->in.handle);
19837                 }
19838                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19839                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19840                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19841                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19844                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19845                 if (_ptr_buffer) {
19846                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19847                 } else {
19848                         r->in.buffer = NULL;
19849                 }
19850                 if (r->in.buffer) {
19851                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19852                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19853                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19854                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19855                 }
19856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19857                 NDR_PULL_ALLOC(ndr, r->out.needed);
19858                 ZERO_STRUCTP(r->out.needed);
19859         }
19860         if (flags & NDR_OUT) {
19861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19862                 if (_ptr_info) {
19863                         NDR_PULL_ALLOC(ndr, r->out.info);
19864                 } else {
19865                         r->out.info = NULL;
19866                 }
19867                 if (r->out.info) {
19868                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19869                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19870                         {
19871                                 struct ndr_pull *_ndr_info;
19872                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19873                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19874                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19875                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19876                         }
19877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19878                 }
19879                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19880                         NDR_PULL_ALLOC(ndr, r->out.needed);
19881                 }
19882                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19883                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19887         }
19888         return NDR_ERR_SUCCESS;
19889 }
19890
19891 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19892 {
19893         ndr_print_struct(ndr, name, "spoolss_GetJob");
19894         ndr->depth++;
19895         if (flags & NDR_SET_VALUES) {
19896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19897         }
19898         if (flags & NDR_IN) {
19899                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19900                 ndr->depth++;
19901                 ndr_print_ptr(ndr, "handle", r->in.handle);
19902                 ndr->depth++;
19903                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19904                 ndr->depth--;
19905                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19906                 ndr_print_uint32(ndr, "level", r->in.level);
19907                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19908                 ndr->depth++;
19909                 if (r->in.buffer) {
19910                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19911                 }
19912                 ndr->depth--;
19913                 ndr_print_uint32(ndr, "offered", r->in.offered);
19914                 ndr->depth--;
19915         }
19916         if (flags & NDR_OUT) {
19917                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19918                 ndr->depth++;
19919                 ndr_print_ptr(ndr, "info", r->out.info);
19920                 ndr->depth++;
19921                 if (r->out.info) {
19922                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19923                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19924                 }
19925                 ndr->depth--;
19926                 ndr_print_ptr(ndr, "needed", r->out.needed);
19927                 ndr->depth++;
19928                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19929                 ndr->depth--;
19930                 ndr_print_WERROR(ndr, "result", r->out.result);
19931                 ndr->depth--;
19932         }
19933         ndr->depth--;
19934 }
19935
19936 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19937 {
19938         if (flags & NDR_IN) {
19939                 if (r->in.handle == NULL) {
19940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19941                 }
19942                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19946                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19947                 if (r->in.buffer) {
19948                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19949                 }
19950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19951         }
19952         if (flags & NDR_OUT) {
19953                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19954                 if (r->out.info) {
19955                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19956                 }
19957                 if (r->out.needed == NULL) {
19958                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19959                 }
19960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19961                 if (r->out.count == NULL) {
19962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19963                 }
19964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19965                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19966         }
19967         return NDR_ERR_SUCCESS;
19968 }
19969
19970 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19971 {
19972         uint32_t _ptr_buffer;
19973         uint32_t _ptr_info;
19974         TALLOC_CTX *_mem_save_handle_0;
19975         TALLOC_CTX *_mem_save_buffer_0;
19976         TALLOC_CTX *_mem_save_info_0;
19977         TALLOC_CTX *_mem_save_needed_0;
19978         TALLOC_CTX *_mem_save_count_0;
19979         if (flags & NDR_IN) {
19980                 ZERO_STRUCT(r->out);
19981
19982                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19983                         NDR_PULL_ALLOC(ndr, r->in.handle);
19984                 }
19985                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19986                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19987                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19988                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19992                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19993                 if (_ptr_buffer) {
19994                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19995                 } else {
19996                         r->in.buffer = NULL;
19997                 }
19998                 if (r->in.buffer) {
19999                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20000                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20001                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20003                 }
20004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20005                 NDR_PULL_ALLOC(ndr, r->out.needed);
20006                 ZERO_STRUCTP(r->out.needed);
20007                 NDR_PULL_ALLOC(ndr, r->out.count);
20008                 ZERO_STRUCTP(r->out.count);
20009         }
20010         if (flags & NDR_OUT) {
20011                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20012                 if (_ptr_info) {
20013                         NDR_PULL_ALLOC(ndr, r->out.info);
20014                 } else {
20015                         r->out.info = NULL;
20016                 }
20017                 if (r->out.info) {
20018                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20019                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20020                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20021                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20022                 }
20023                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20024                         NDR_PULL_ALLOC(ndr, r->out.needed);
20025                 }
20026                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20027                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20030                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20031                         NDR_PULL_ALLOC(ndr, r->out.count);
20032                 }
20033                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20034                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20038         }
20039         return NDR_ERR_SUCCESS;
20040 }
20041
20042 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20043 {
20044         uint32_t cntr_info_0;
20045         if (flags & NDR_IN) {
20046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20048         }
20049         if (flags & NDR_OUT) {
20050                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20051                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20052                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20053                 }
20054                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20055                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20056                 }
20057         }
20058         return NDR_ERR_SUCCESS;
20059 }
20060
20061 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20062 {
20063         uint32_t cntr_info_0;
20064         TALLOC_CTX *_mem_save_info_0;
20065         if (flags & NDR_IN) {
20066                 ZERO_STRUCT(r->out);
20067
20068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20070         }
20071         if (flags & NDR_OUT) {
20072                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20073                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20074                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20075                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20076                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20077                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20078                 }
20079                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20080                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20081                 }
20082                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20083         }
20084         return NDR_ERR_SUCCESS;
20085 }
20086
20087 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20088 {
20089         uint32_t cntr_info_2;
20090         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20091         ndr->depth++;
20092         if (flags & NDR_SET_VALUES) {
20093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20094         }
20095         if (flags & NDR_IN) {
20096                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20097                 ndr->depth++;
20098                 ndr_print_ptr(ndr, "handle", r->in.handle);
20099                 ndr->depth++;
20100                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20101                 ndr->depth--;
20102                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20103                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20104                 ndr_print_uint32(ndr, "level", r->in.level);
20105                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20106                 ndr->depth++;
20107                 if (r->in.buffer) {
20108                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20109                 }
20110                 ndr->depth--;
20111                 ndr_print_uint32(ndr, "offered", r->in.offered);
20112                 ndr->depth--;
20113         }
20114         if (flags & NDR_OUT) {
20115                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
20116                 ndr->depth++;
20117                 ndr_print_ptr(ndr, "count", r->out.count);
20118                 ndr->depth++;
20119                 ndr_print_uint32(ndr, "count", *r->out.count);
20120                 ndr->depth--;
20121                 ndr_print_ptr(ndr, "info", r->out.info);
20122                 ndr->depth++;
20123                 ndr_print_ptr(ndr, "info", *r->out.info);
20124                 ndr->depth++;
20125                 if (*r->out.info) {
20126                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20127                         ndr->depth++;
20128                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20129                                 char *idx_2=NULL;
20130                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20131                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20132                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20133                                         free(idx_2);
20134                                 }
20135                         }
20136                         ndr->depth--;
20137                 }
20138                 ndr->depth--;
20139                 ndr->depth--;
20140                 ndr_print_ptr(ndr, "needed", r->out.needed);
20141                 ndr->depth++;
20142                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20143                 ndr->depth--;
20144                 ndr_print_WERROR(ndr, "result", r->out.result);
20145                 ndr->depth--;
20146         }
20147         ndr->depth--;
20148 }
20149
20150 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
20151 {
20152         if (flags & NDR_IN) {
20153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20154                 if (r->in.server) {
20155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20158                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20159                 }
20160                 if (r->in.info_ctr == NULL) {
20161                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20162                 }
20163                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20164                 if (r->in.devmode_ctr == NULL) {
20165                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20166                 }
20167                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20168                 if (r->in.secdesc_ctr == NULL) {
20169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20170                 }
20171                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20172         }
20173         if (flags & NDR_OUT) {
20174                 if (r->out.handle == NULL) {
20175                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20176                 }
20177                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20178                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20179         }
20180         return NDR_ERR_SUCCESS;
20181 }
20182
20183 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
20184 {
20185         uint32_t _ptr_server;
20186         TALLOC_CTX *_mem_save_server_0;
20187         TALLOC_CTX *_mem_save_info_ctr_0;
20188         TALLOC_CTX *_mem_save_devmode_ctr_0;
20189         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20190         TALLOC_CTX *_mem_save_handle_0;
20191         if (flags & NDR_IN) {
20192                 ZERO_STRUCT(r->out);
20193
20194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20195                 if (_ptr_server) {
20196                         NDR_PULL_ALLOC(ndr, r->in.server);
20197                 } else {
20198                         r->in.server = NULL;
20199                 }
20200                 if (r->in.server) {
20201                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20202                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20203                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20204                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20205                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20206                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
20207                         }
20208                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20211                 }
20212                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20213                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20214                 }
20215                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20216                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20217                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20218                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20219                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20220                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20221                 }
20222                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20223                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20224                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20226                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20227                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20228                 }
20229                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20230                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20231                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20232                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20233                 NDR_PULL_ALLOC(ndr, r->out.handle);
20234                 ZERO_STRUCTP(r->out.handle);
20235         }
20236         if (flags & NDR_OUT) {
20237                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20238                         NDR_PULL_ALLOC(ndr, r->out.handle);
20239                 }
20240                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20241                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20242                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20243                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20244                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20245         }
20246         return NDR_ERR_SUCCESS;
20247 }
20248
20249 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
20250 {
20251         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
20252         ndr->depth++;
20253         if (flags & NDR_SET_VALUES) {
20254                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20255         }
20256         if (flags & NDR_IN) {
20257                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
20258                 ndr->depth++;
20259                 ndr_print_ptr(ndr, "server", r->in.server);
20260                 ndr->depth++;
20261                 if (r->in.server) {
20262                         ndr_print_string(ndr, "server", r->in.server);
20263                 }
20264                 ndr->depth--;
20265                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20266                 ndr->depth++;
20267                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20268                 ndr->depth--;
20269                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20270                 ndr->depth++;
20271                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20272                 ndr->depth--;
20273                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20274                 ndr->depth++;
20275                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20276                 ndr->depth--;
20277                 ndr->depth--;
20278         }
20279         if (flags & NDR_OUT) {
20280                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
20281                 ndr->depth++;
20282                 ndr_print_ptr(ndr, "handle", r->out.handle);
20283                 ndr->depth++;
20284                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20285                 ndr->depth--;
20286                 ndr_print_WERROR(ndr, "result", r->out.result);
20287                 ndr->depth--;
20288         }
20289         ndr->depth--;
20290 }
20291
20292 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
20293 {
20294         if (flags & NDR_IN) {
20295                 if (r->in.handle == NULL) {
20296                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20297                 }
20298                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20299         }
20300         if (flags & NDR_OUT) {
20301                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20302         }
20303         return NDR_ERR_SUCCESS;
20304 }
20305
20306 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
20307 {
20308         TALLOC_CTX *_mem_save_handle_0;
20309         if (flags & NDR_IN) {
20310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20311                         NDR_PULL_ALLOC(ndr, r->in.handle);
20312                 }
20313                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20314                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20315                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20317         }
20318         if (flags & NDR_OUT) {
20319                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20320         }
20321         return NDR_ERR_SUCCESS;
20322 }
20323
20324 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
20325 {
20326         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
20327         ndr->depth++;
20328         if (flags & NDR_SET_VALUES) {
20329                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20330         }
20331         if (flags & NDR_IN) {
20332                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
20333                 ndr->depth++;
20334                 ndr_print_ptr(ndr, "handle", r->in.handle);
20335                 ndr->depth++;
20336                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20337                 ndr->depth--;
20338                 ndr->depth--;
20339         }
20340         if (flags & NDR_OUT) {
20341                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
20342                 ndr->depth++;
20343                 ndr_print_WERROR(ndr, "result", r->out.result);
20344                 ndr->depth--;
20345         }
20346         ndr->depth--;
20347 }
20348
20349 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
20350 {
20351         if (flags & NDR_IN) {
20352                 if (r->in.handle == NULL) {
20353                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20354                 }
20355                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20356                 if (r->in.info_ctr == NULL) {
20357                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20358                 }
20359                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20360                 if (r->in.devmode_ctr == NULL) {
20361                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20362                 }
20363                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20364                 if (r->in.secdesc_ctr == NULL) {
20365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20366                 }
20367                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20368                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
20369         }
20370         if (flags & NDR_OUT) {
20371                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20372         }
20373         return NDR_ERR_SUCCESS;
20374 }
20375
20376 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
20377 {
20378         TALLOC_CTX *_mem_save_handle_0;
20379         TALLOC_CTX *_mem_save_info_ctr_0;
20380         TALLOC_CTX *_mem_save_devmode_ctr_0;
20381         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20382         if (flags & NDR_IN) {
20383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20384                         NDR_PULL_ALLOC(ndr, r->in.handle);
20385                 }
20386                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20387                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20388                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20389                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20390                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20391                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20392                 }
20393                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20394                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20395                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20396                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20397                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20398                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20399                 }
20400                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20401                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20402                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20403                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20404                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20405                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20406                 }
20407                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20408                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20409                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20411                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
20412         }
20413         if (flags & NDR_OUT) {
20414                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20415         }
20416         return NDR_ERR_SUCCESS;
20417 }
20418
20419 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
20420 {
20421         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
20422         ndr->depth++;
20423         if (flags & NDR_SET_VALUES) {
20424                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20425         }
20426         if (flags & NDR_IN) {
20427                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
20428                 ndr->depth++;
20429                 ndr_print_ptr(ndr, "handle", r->in.handle);
20430                 ndr->depth++;
20431                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20432                 ndr->depth--;
20433                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20434                 ndr->depth++;
20435                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20436                 ndr->depth--;
20437                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
20438                 ndr->depth++;
20439                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
20440                 ndr->depth--;
20441                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20442                 ndr->depth++;
20443                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
20444                 ndr->depth--;
20445                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
20446                 ndr->depth--;
20447         }
20448         if (flags & NDR_OUT) {
20449                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
20450                 ndr->depth++;
20451                 ndr_print_WERROR(ndr, "result", r->out.result);
20452                 ndr->depth--;
20453         }
20454         ndr->depth--;
20455 }
20456
20457 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
20458 {
20459         if (flags & NDR_IN) {
20460                 if (r->in.handle == NULL) {
20461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20462                 }
20463                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20466                 if (r->in.buffer) {
20467                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20468                 }
20469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20470         }
20471         if (flags & NDR_OUT) {
20472                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20473                 if (r->out.info) {
20474                         {
20475                                 struct ndr_push *_ndr_info;
20476                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20477                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20478                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20479                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20480                         }
20481                 }
20482                 if (r->out.needed == NULL) {
20483                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20484                 }
20485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20486                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20487         }
20488         return NDR_ERR_SUCCESS;
20489 }
20490
20491 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
20492 {
20493         uint32_t _ptr_buffer;
20494         uint32_t _ptr_info;
20495         TALLOC_CTX *_mem_save_handle_0;
20496         TALLOC_CTX *_mem_save_buffer_0;
20497         TALLOC_CTX *_mem_save_info_0;
20498         TALLOC_CTX *_mem_save_needed_0;
20499         if (flags & NDR_IN) {
20500                 ZERO_STRUCT(r->out);
20501
20502                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20503                         NDR_PULL_ALLOC(ndr, r->in.handle);
20504                 }
20505                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20506                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20507                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20508                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20511                 if (_ptr_buffer) {
20512                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20513                 } else {
20514                         r->in.buffer = NULL;
20515                 }
20516                 if (r->in.buffer) {
20517                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20518                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20519                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20521                 }
20522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20523                 NDR_PULL_ALLOC(ndr, r->out.needed);
20524                 ZERO_STRUCTP(r->out.needed);
20525         }
20526         if (flags & NDR_OUT) {
20527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20528                 if (_ptr_info) {
20529                         NDR_PULL_ALLOC(ndr, r->out.info);
20530                 } else {
20531                         r->out.info = NULL;
20532                 }
20533                 if (r->out.info) {
20534                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20535                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20536                         {
20537                                 struct ndr_pull *_ndr_info;
20538                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20539                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20540                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20541                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20542                         }
20543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20544                 }
20545                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20546                         NDR_PULL_ALLOC(ndr, r->out.needed);
20547                 }
20548                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20549                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20551                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20552                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20553         }
20554         return NDR_ERR_SUCCESS;
20555 }
20556
20557 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
20558 {
20559         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
20560         ndr->depth++;
20561         if (flags & NDR_SET_VALUES) {
20562                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20563         }
20564         if (flags & NDR_IN) {
20565                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
20566                 ndr->depth++;
20567                 ndr_print_ptr(ndr, "handle", r->in.handle);
20568                 ndr->depth++;
20569                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20570                 ndr->depth--;
20571                 ndr_print_uint32(ndr, "level", r->in.level);
20572                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20573                 ndr->depth++;
20574                 if (r->in.buffer) {
20575                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20576                 }
20577                 ndr->depth--;
20578                 ndr_print_uint32(ndr, "offered", r->in.offered);
20579                 ndr->depth--;
20580         }
20581         if (flags & NDR_OUT) {
20582                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
20583                 ndr->depth++;
20584                 ndr_print_ptr(ndr, "info", r->out.info);
20585                 ndr->depth++;
20586                 if (r->out.info) {
20587                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20588                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
20589                 }
20590                 ndr->depth--;
20591                 ndr_print_ptr(ndr, "needed", r->out.needed);
20592                 ndr->depth++;
20593                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20594                 ndr->depth--;
20595                 ndr_print_WERROR(ndr, "result", r->out.result);
20596                 ndr->depth--;
20597         }
20598         ndr->depth--;
20599 }
20600
20601 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
20602 {
20603         if (flags & NDR_IN) {
20604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20605                 if (r->in.servername) {
20606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20607                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20609                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20610                 }
20611                 if (r->in.info_ctr == NULL) {
20612                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20613                 }
20614                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20615         }
20616         if (flags & NDR_OUT) {
20617                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20618         }
20619         return NDR_ERR_SUCCESS;
20620 }
20621
20622 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
20623 {
20624         uint32_t _ptr_servername;
20625         TALLOC_CTX *_mem_save_servername_0;
20626         TALLOC_CTX *_mem_save_info_ctr_0;
20627         if (flags & NDR_IN) {
20628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20629                 if (_ptr_servername) {
20630                         NDR_PULL_ALLOC(ndr, r->in.servername);
20631                 } else {
20632                         r->in.servername = NULL;
20633                 }
20634                 if (r->in.servername) {
20635                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20636                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20637                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20638                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20639                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20640                                 return 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));
20641                         }
20642                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20643                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20645                 }
20646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20647                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20648                 }
20649                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20650                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20651                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20653         }
20654         if (flags & NDR_OUT) {
20655                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20656         }
20657         return NDR_ERR_SUCCESS;
20658 }
20659
20660 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
20661 {
20662         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
20663         ndr->depth++;
20664         if (flags & NDR_SET_VALUES) {
20665                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20666         }
20667         if (flags & NDR_IN) {
20668                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
20669                 ndr->depth++;
20670                 ndr_print_ptr(ndr, "servername", r->in.servername);
20671                 ndr->depth++;
20672                 if (r->in.servername) {
20673                         ndr_print_string(ndr, "servername", r->in.servername);
20674                 }
20675                 ndr->depth--;
20676                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20677                 ndr->depth++;
20678                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20679                 ndr->depth--;
20680                 ndr->depth--;
20681         }
20682         if (flags & NDR_OUT) {
20683                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
20684                 ndr->depth++;
20685                 ndr_print_WERROR(ndr, "result", r->out.result);
20686                 ndr->depth--;
20687         }
20688         ndr->depth--;
20689 }
20690
20691 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
20692 {
20693         if (flags & NDR_IN) {
20694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20695                 if (r->in.server) {
20696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20699                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20700                 }
20701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20702                 if (r->in.environment) {
20703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20706                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20707                 }
20708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20710                 if (r->in.buffer) {
20711                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20712                 }
20713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20714         }
20715         if (flags & NDR_OUT) {
20716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20717                 if (r->out.info) {
20718                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20719                 }
20720                 if (r->out.needed == NULL) {
20721                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20722                 }
20723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20724                 if (r->out.count == NULL) {
20725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20726                 }
20727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20728                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20729         }
20730         return NDR_ERR_SUCCESS;
20731 }
20732
20733 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
20734 {
20735         uint32_t _ptr_server;
20736         uint32_t _ptr_environment;
20737         uint32_t _ptr_buffer;
20738         uint32_t _ptr_info;
20739         TALLOC_CTX *_mem_save_server_0;
20740         TALLOC_CTX *_mem_save_environment_0;
20741         TALLOC_CTX *_mem_save_buffer_0;
20742         TALLOC_CTX *_mem_save_info_0;
20743         TALLOC_CTX *_mem_save_needed_0;
20744         TALLOC_CTX *_mem_save_count_0;
20745         if (flags & NDR_IN) {
20746                 ZERO_STRUCT(r->out);
20747
20748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20749                 if (_ptr_server) {
20750                         NDR_PULL_ALLOC(ndr, r->in.server);
20751                 } else {
20752                         r->in.server = NULL;
20753                 }
20754                 if (r->in.server) {
20755                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20756                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20757                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20758                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20759                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20760                                 return 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));
20761                         }
20762                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20763                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20764                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20765                 }
20766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20767                 if (_ptr_environment) {
20768                         NDR_PULL_ALLOC(ndr, r->in.environment);
20769                 } else {
20770                         r->in.environment = NULL;
20771                 }
20772                 if (r->in.environment) {
20773                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20774                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20775                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20776                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20777                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20778                                 return 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));
20779                         }
20780                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20781                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20783                 }
20784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20786                 if (_ptr_buffer) {
20787                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20788                 } else {
20789                         r->in.buffer = NULL;
20790                 }
20791                 if (r->in.buffer) {
20792                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20793                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20794                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20796                 }
20797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20798                 NDR_PULL_ALLOC(ndr, r->out.needed);
20799                 ZERO_STRUCTP(r->out.needed);
20800                 NDR_PULL_ALLOC(ndr, r->out.count);
20801                 ZERO_STRUCTP(r->out.count);
20802         }
20803         if (flags & NDR_OUT) {
20804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20805                 if (_ptr_info) {
20806                         NDR_PULL_ALLOC(ndr, r->out.info);
20807                 } else {
20808                         r->out.info = NULL;
20809                 }
20810                 if (r->out.info) {
20811                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20812                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20813                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20815                 }
20816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20817                         NDR_PULL_ALLOC(ndr, r->out.needed);
20818                 }
20819                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20820                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20824                         NDR_PULL_ALLOC(ndr, r->out.count);
20825                 }
20826                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20827                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20830                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20831         }
20832         return NDR_ERR_SUCCESS;
20833 }
20834
20835 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
20836 {
20837         uint32_t cntr_info_0;
20838         if (flags & NDR_IN) {
20839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20841         }
20842         if (flags & NDR_OUT) {
20843                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20844                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20845                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20846                 }
20847                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20848                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20849                 }
20850         }
20851         return NDR_ERR_SUCCESS;
20852 }
20853
20854 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
20855 {
20856         uint32_t cntr_info_0;
20857         TALLOC_CTX *_mem_save_info_0;
20858         if (flags & NDR_IN) {
20859                 ZERO_STRUCT(r->out);
20860
20861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20863         }
20864         if (flags & NDR_OUT) {
20865                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20866                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20867                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20868                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20869                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20870                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20871                 }
20872                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20873                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20874                 }
20875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20876         }
20877         return NDR_ERR_SUCCESS;
20878 }
20879
20880 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
20881 {
20882         uint32_t cntr_info_2;
20883         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
20884         ndr->depth++;
20885         if (flags & NDR_SET_VALUES) {
20886                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20887         }
20888         if (flags & NDR_IN) {
20889                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
20890                 ndr->depth++;
20891                 ndr_print_ptr(ndr, "server", r->in.server);
20892                 ndr->depth++;
20893                 if (r->in.server) {
20894                         ndr_print_string(ndr, "server", r->in.server);
20895                 }
20896                 ndr->depth--;
20897                 ndr_print_ptr(ndr, "environment", r->in.environment);
20898                 ndr->depth++;
20899                 if (r->in.environment) {
20900                         ndr_print_string(ndr, "environment", r->in.environment);
20901                 }
20902                 ndr->depth--;
20903                 ndr_print_uint32(ndr, "level", r->in.level);
20904                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20905                 ndr->depth++;
20906                 if (r->in.buffer) {
20907                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20908                 }
20909                 ndr->depth--;
20910                 ndr_print_uint32(ndr, "offered", r->in.offered);
20911                 ndr->depth--;
20912         }
20913         if (flags & NDR_OUT) {
20914                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
20915                 ndr->depth++;
20916                 ndr_print_ptr(ndr, "count", r->out.count);
20917                 ndr->depth++;
20918                 ndr_print_uint32(ndr, "count", *r->out.count);
20919                 ndr->depth--;
20920                 ndr_print_ptr(ndr, "info", r->out.info);
20921                 ndr->depth++;
20922                 ndr_print_ptr(ndr, "info", *r->out.info);
20923                 ndr->depth++;
20924                 if (*r->out.info) {
20925                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20926                         ndr->depth++;
20927                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20928                                 char *idx_2=NULL;
20929                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20930                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20931                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20932                                         free(idx_2);
20933                                 }
20934                         }
20935                         ndr->depth--;
20936                 }
20937                 ndr->depth--;
20938                 ndr->depth--;
20939                 ndr_print_ptr(ndr, "needed", r->out.needed);
20940                 ndr->depth++;
20941                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20942                 ndr->depth--;
20943                 ndr_print_WERROR(ndr, "result", r->out.result);
20944                 ndr->depth--;
20945         }
20946         ndr->depth--;
20947 }
20948
20949 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20950 {
20951         if (flags & NDR_IN) {
20952                 if (r->in.handle == NULL) {
20953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20954                 }
20955                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20956                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
20957                 if (r->in.architecture) {
20958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20959                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20961                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20962                 }
20963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20965                 if (r->in.buffer) {
20966                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20967                 }
20968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20969         }
20970         if (flags & NDR_OUT) {
20971                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20972                 if (r->out.info) {
20973                         {
20974                                 struct ndr_push *_ndr_info;
20975                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20976                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20977                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20978                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20979                         }
20980                 }
20981                 if (r->out.needed == NULL) {
20982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20983                 }
20984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20985                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20986         }
20987         return NDR_ERR_SUCCESS;
20988 }
20989
20990 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20991 {
20992         uint32_t _ptr_architecture;
20993         uint32_t _ptr_buffer;
20994         uint32_t _ptr_info;
20995         TALLOC_CTX *_mem_save_handle_0;
20996         TALLOC_CTX *_mem_save_architecture_0;
20997         TALLOC_CTX *_mem_save_buffer_0;
20998         TALLOC_CTX *_mem_save_info_0;
20999         TALLOC_CTX *_mem_save_needed_0;
21000         if (flags & NDR_IN) {
21001                 ZERO_STRUCT(r->out);
21002
21003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21004                         NDR_PULL_ALLOC(ndr, r->in.handle);
21005                 }
21006                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21007                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21008                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21011                 if (_ptr_architecture) {
21012                         NDR_PULL_ALLOC(ndr, r->in.architecture);
21013                 } else {
21014                         r->in.architecture = NULL;
21015                 }
21016                 if (r->in.architecture) {
21017                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
21018                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
21019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21021                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21022                                 return 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));
21023                         }
21024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
21027                 }
21028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21029                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21030                 if (_ptr_buffer) {
21031                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21032                 } else {
21033                         r->in.buffer = NULL;
21034                 }
21035                 if (r->in.buffer) {
21036                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21037                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21038                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21040                 }
21041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21042                 NDR_PULL_ALLOC(ndr, r->out.needed);
21043                 ZERO_STRUCTP(r->out.needed);
21044         }
21045         if (flags & NDR_OUT) {
21046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21047                 if (_ptr_info) {
21048                         NDR_PULL_ALLOC(ndr, r->out.info);
21049                 } else {
21050                         r->out.info = NULL;
21051                 }
21052                 if (r->out.info) {
21053                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21054                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21055                         {
21056                                 struct ndr_pull *_ndr_info;
21057                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21058                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21059                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21060                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21061                         }
21062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21063                 }
21064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21065                         NDR_PULL_ALLOC(ndr, r->out.needed);
21066                 }
21067                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21068                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21070                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21071                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21072         }
21073         return NDR_ERR_SUCCESS;
21074 }
21075
21076 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
21077 {
21078         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21079         ndr->depth++;
21080         if (flags & NDR_SET_VALUES) {
21081                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21082         }
21083         if (flags & NDR_IN) {
21084                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21085                 ndr->depth++;
21086                 ndr_print_ptr(ndr, "handle", r->in.handle);
21087                 ndr->depth++;
21088                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21089                 ndr->depth--;
21090                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
21091                 ndr->depth++;
21092                 if (r->in.architecture) {
21093                         ndr_print_string(ndr, "architecture", r->in.architecture);
21094                 }
21095                 ndr->depth--;
21096                 ndr_print_uint32(ndr, "level", r->in.level);
21097                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21098                 ndr->depth++;
21099                 if (r->in.buffer) {
21100                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21101                 }
21102                 ndr->depth--;
21103                 ndr_print_uint32(ndr, "offered", r->in.offered);
21104                 ndr->depth--;
21105         }
21106         if (flags & NDR_OUT) {
21107                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
21108                 ndr->depth++;
21109                 ndr_print_ptr(ndr, "info", r->out.info);
21110                 ndr->depth++;
21111                 if (r->out.info) {
21112                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21113                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
21114                 }
21115                 ndr->depth--;
21116                 ndr_print_ptr(ndr, "needed", r->out.needed);
21117                 ndr->depth++;
21118                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21119                 ndr->depth--;
21120                 ndr_print_WERROR(ndr, "result", r->out.result);
21121                 ndr->depth--;
21122         }
21123         ndr->depth--;
21124 }
21125
21126 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21127 {
21128         if (flags & NDR_IN) {
21129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21130                 if (r->in.server) {
21131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21134                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21135                 }
21136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21137                 if (r->in.environment) {
21138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21141                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21142                 }
21143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21145                 if (r->in.buffer) {
21146                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21147                 }
21148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21149         }
21150         if (flags & NDR_OUT) {
21151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21152                 if (r->out.info) {
21153                         {
21154                                 struct ndr_push *_ndr_info;
21155                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21156                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21157                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21158                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21159                         }
21160                 }
21161                 if (r->out.needed == NULL) {
21162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21163                 }
21164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21165                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21166         }
21167         return NDR_ERR_SUCCESS;
21168 }
21169
21170 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
21171 {
21172         uint32_t _ptr_server;
21173         uint32_t _ptr_environment;
21174         uint32_t _ptr_buffer;
21175         uint32_t _ptr_info;
21176         TALLOC_CTX *_mem_save_server_0;
21177         TALLOC_CTX *_mem_save_environment_0;
21178         TALLOC_CTX *_mem_save_buffer_0;
21179         TALLOC_CTX *_mem_save_info_0;
21180         TALLOC_CTX *_mem_save_needed_0;
21181         if (flags & NDR_IN) {
21182                 ZERO_STRUCT(r->out);
21183
21184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21185                 if (_ptr_server) {
21186                         NDR_PULL_ALLOC(ndr, r->in.server);
21187                 } else {
21188                         r->in.server = NULL;
21189                 }
21190                 if (r->in.server) {
21191                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21192                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21194                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21195                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21196                                 return 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));
21197                         }
21198                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21199                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21201                 }
21202                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21203                 if (_ptr_environment) {
21204                         NDR_PULL_ALLOC(ndr, r->in.environment);
21205                 } else {
21206                         r->in.environment = NULL;
21207                 }
21208                 if (r->in.environment) {
21209                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21210                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21213                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21214                                 return 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));
21215                         }
21216                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21217                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21219                 }
21220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21222                 if (_ptr_buffer) {
21223                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21224                 } else {
21225                         r->in.buffer = NULL;
21226                 }
21227                 if (r->in.buffer) {
21228                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21229                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21230                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21232                 }
21233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21234                 NDR_PULL_ALLOC(ndr, r->out.needed);
21235                 ZERO_STRUCTP(r->out.needed);
21236         }
21237         if (flags & NDR_OUT) {
21238                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21239                 if (_ptr_info) {
21240                         NDR_PULL_ALLOC(ndr, r->out.info);
21241                 } else {
21242                         r->out.info = NULL;
21243                 }
21244                 if (r->out.info) {
21245                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21246                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21247                         {
21248                                 struct ndr_pull *_ndr_info;
21249                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21250                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21251                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21252                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21253                         }
21254                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21255                 }
21256                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21257                         NDR_PULL_ALLOC(ndr, r->out.needed);
21258                 }
21259                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21260                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21262                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21263                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21264         }
21265         return NDR_ERR_SUCCESS;
21266 }
21267
21268 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21269 {
21270         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
21271         ndr->depth++;
21272         if (flags & NDR_SET_VALUES) {
21273                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21274         }
21275         if (flags & NDR_IN) {
21276                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
21277                 ndr->depth++;
21278                 ndr_print_ptr(ndr, "server", r->in.server);
21279                 ndr->depth++;
21280                 if (r->in.server) {
21281                         ndr_print_string(ndr, "server", r->in.server);
21282                 }
21283                 ndr->depth--;
21284                 ndr_print_ptr(ndr, "environment", r->in.environment);
21285                 ndr->depth++;
21286                 if (r->in.environment) {
21287                         ndr_print_string(ndr, "environment", r->in.environment);
21288                 }
21289                 ndr->depth--;
21290                 ndr_print_uint32(ndr, "level", r->in.level);
21291                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21292                 ndr->depth++;
21293                 if (r->in.buffer) {
21294                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21295                 }
21296                 ndr->depth--;
21297                 ndr_print_uint32(ndr, "offered", r->in.offered);
21298                 ndr->depth--;
21299         }
21300         if (flags & NDR_OUT) {
21301                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
21302                 ndr->depth++;
21303                 ndr_print_ptr(ndr, "info", r->out.info);
21304                 ndr->depth++;
21305                 if (r->out.info) {
21306                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21307                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
21308                 }
21309                 ndr->depth--;
21310                 ndr_print_ptr(ndr, "needed", r->out.needed);
21311                 ndr->depth++;
21312                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21313                 ndr->depth--;
21314                 ndr_print_WERROR(ndr, "result", r->out.result);
21315                 ndr->depth--;
21316         }
21317         ndr->depth--;
21318 }
21319
21320 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
21321 {
21322         if (flags & NDR_IN) {
21323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21324                 if (r->in.server) {
21325                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21326                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21327                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21328                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21329                 }
21330                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21331                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21332                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21333                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21334                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21335                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21336                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
21337                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21338         }
21339         if (flags & NDR_OUT) {
21340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21341         }
21342         return NDR_ERR_SUCCESS;
21343 }
21344
21345 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
21346 {
21347         uint32_t _ptr_server;
21348         TALLOC_CTX *_mem_save_server_0;
21349         if (flags & NDR_IN) {
21350                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21351                 if (_ptr_server) {
21352                         NDR_PULL_ALLOC(ndr, r->in.server);
21353                 } else {
21354                         r->in.server = NULL;
21355                 }
21356                 if (r->in.server) {
21357                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21358                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21359                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21360                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21361                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21362                                 return 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));
21363                         }
21364                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21365                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21366                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21367                 }
21368                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21369                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21370                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21371                         return 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));
21372                 }
21373                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21374                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21375                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
21376                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
21377                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
21378                         return 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));
21379                 }
21380                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
21381                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
21382         }
21383         if (flags & NDR_OUT) {
21384                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21385         }
21386         return NDR_ERR_SUCCESS;
21387 }
21388
21389 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
21390 {
21391         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
21392         ndr->depth++;
21393         if (flags & NDR_SET_VALUES) {
21394                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21395         }
21396         if (flags & NDR_IN) {
21397                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
21398                 ndr->depth++;
21399                 ndr_print_ptr(ndr, "server", r->in.server);
21400                 ndr->depth++;
21401                 if (r->in.server) {
21402                         ndr_print_string(ndr, "server", r->in.server);
21403                 }
21404                 ndr->depth--;
21405                 ndr_print_string(ndr, "architecture", r->in.architecture);
21406                 ndr_print_string(ndr, "driver", r->in.driver);
21407                 ndr->depth--;
21408         }
21409         if (flags & NDR_OUT) {
21410                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
21411                 ndr->depth++;
21412                 ndr_print_WERROR(ndr, "result", r->out.result);
21413                 ndr->depth--;
21414         }
21415         ndr->depth--;
21416 }
21417
21418 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
21419 {
21420         if (flags & NDR_IN) {
21421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21422                 if (r->in.server) {
21423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21426                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21427                 }
21428                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21429                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21430                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21431                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21432                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
21433                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21434                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
21435                 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));
21436                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
21437                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21438                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
21439                 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));
21440         }
21441         if (flags & NDR_OUT) {
21442                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21443         }
21444         return NDR_ERR_SUCCESS;
21445 }
21446
21447 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
21448 {
21449         uint32_t _ptr_server;
21450         TALLOC_CTX *_mem_save_server_0;
21451         if (flags & NDR_IN) {
21452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21453                 if (_ptr_server) {
21454                         NDR_PULL_ALLOC(ndr, r->in.server);
21455                 } else {
21456                         r->in.server = NULL;
21457                 }
21458                 if (r->in.server) {
21459                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21460                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21463                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21464                                 return 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));
21465                         }
21466                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21467                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21469                 }
21470                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21471                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21472                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21473                         return 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));
21474                 }
21475                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21476                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21477                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
21478                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
21479                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
21480                         return 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));
21481                 }
21482                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
21483                 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));
21484                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
21485                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
21486                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
21487                         return 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));
21488                 }
21489                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
21490                 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));
21491         }
21492         if (flags & NDR_OUT) {
21493                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21494         }
21495         return NDR_ERR_SUCCESS;
21496 }
21497
21498 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
21499 {
21500         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
21501         ndr->depth++;
21502         if (flags & NDR_SET_VALUES) {
21503                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21504         }
21505         if (flags & NDR_IN) {
21506                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
21507                 ndr->depth++;
21508                 ndr_print_ptr(ndr, "server", r->in.server);
21509                 ndr->depth++;
21510                 if (r->in.server) {
21511                         ndr_print_string(ndr, "server", r->in.server);
21512                 }
21513                 ndr->depth--;
21514                 ndr_print_string(ndr, "architecture", r->in.architecture);
21515                 ndr_print_string(ndr, "path_name", r->in.path_name);
21516                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
21517                 ndr->depth--;
21518         }
21519         if (flags & NDR_OUT) {
21520                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
21521                 ndr->depth++;
21522                 ndr_print_WERROR(ndr, "result", r->out.result);
21523                 ndr->depth--;
21524         }
21525         ndr->depth--;
21526 }
21527
21528 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
21529 {
21530         if (flags & NDR_IN) {
21531                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21532                 if (r->in.servername) {
21533                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21535                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21536                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21537                 }
21538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21539                 if (r->in.environment) {
21540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21542                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21543                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21544                 }
21545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21547                 if (r->in.buffer) {
21548                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21549                 }
21550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21551         }
21552         if (flags & NDR_OUT) {
21553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21554                 if (r->out.info) {
21555                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21556                 }
21557                 if (r->out.needed == NULL) {
21558                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21559                 }
21560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21561                 if (r->out.count == NULL) {
21562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21563                 }
21564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21565                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21566         }
21567         return NDR_ERR_SUCCESS;
21568 }
21569
21570 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
21571 {
21572         uint32_t _ptr_servername;
21573         uint32_t _ptr_environment;
21574         uint32_t _ptr_buffer;
21575         uint32_t _ptr_info;
21576         TALLOC_CTX *_mem_save_servername_0;
21577         TALLOC_CTX *_mem_save_environment_0;
21578         TALLOC_CTX *_mem_save_buffer_0;
21579         TALLOC_CTX *_mem_save_info_0;
21580         TALLOC_CTX *_mem_save_needed_0;
21581         TALLOC_CTX *_mem_save_count_0;
21582         if (flags & NDR_IN) {
21583                 ZERO_STRUCT(r->out);
21584
21585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21586                 if (_ptr_servername) {
21587                         NDR_PULL_ALLOC(ndr, r->in.servername);
21588                 } else {
21589                         r->in.servername = NULL;
21590                 }
21591                 if (r->in.servername) {
21592                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21593                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21596                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21597                                 return 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));
21598                         }
21599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21602                 }
21603                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21604                 if (_ptr_environment) {
21605                         NDR_PULL_ALLOC(ndr, r->in.environment);
21606                 } else {
21607                         r->in.environment = NULL;
21608                 }
21609                 if (r->in.environment) {
21610                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21611                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21612                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21613                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21614                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21615                                 return 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));
21616                         }
21617                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21618                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21620                 }
21621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21622                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21623                 if (_ptr_buffer) {
21624                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21625                 } else {
21626                         r->in.buffer = NULL;
21627                 }
21628                 if (r->in.buffer) {
21629                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21630                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21631                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21633                 }
21634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21635                 NDR_PULL_ALLOC(ndr, r->out.needed);
21636                 ZERO_STRUCTP(r->out.needed);
21637                 NDR_PULL_ALLOC(ndr, r->out.count);
21638                 ZERO_STRUCTP(r->out.count);
21639         }
21640         if (flags & NDR_OUT) {
21641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21642                 if (_ptr_info) {
21643                         NDR_PULL_ALLOC(ndr, r->out.info);
21644                 } else {
21645                         r->out.info = NULL;
21646                 }
21647                 if (r->out.info) {
21648                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21649                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21650                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21652                 }
21653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21654                         NDR_PULL_ALLOC(ndr, r->out.needed);
21655                 }
21656                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21657                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21659                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21660                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21661                         NDR_PULL_ALLOC(ndr, r->out.count);
21662                 }
21663                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21664                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21666                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21667                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21668         }
21669         return NDR_ERR_SUCCESS;
21670 }
21671
21672 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
21673 {
21674         uint32_t cntr_info_0;
21675         if (flags & NDR_IN) {
21676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21678         }
21679         if (flags & NDR_OUT) {
21680                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21681                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21682                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21683                 }
21684                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21685                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21686                 }
21687         }
21688         return NDR_ERR_SUCCESS;
21689 }
21690
21691 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
21692 {
21693         uint32_t cntr_info_0;
21694         TALLOC_CTX *_mem_save_info_0;
21695         if (flags & NDR_IN) {
21696                 ZERO_STRUCT(r->out);
21697
21698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21700         }
21701         if (flags & NDR_OUT) {
21702                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21703                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21704                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21705                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21706                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21707                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21708                 }
21709                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21710                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21711                 }
21712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21713         }
21714         return NDR_ERR_SUCCESS;
21715 }
21716
21717 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
21718 {
21719         uint32_t cntr_info_2;
21720         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
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_EnumPrintProcessors");
21727                 ndr->depth++;
21728                 ndr_print_ptr(ndr, "servername", r->in.servername);
21729                 ndr->depth++;
21730                 if (r->in.servername) {
21731                         ndr_print_string(ndr, "servername", r->in.servername);
21732                 }
21733                 ndr->depth--;
21734                 ndr_print_ptr(ndr, "environment", r->in.environment);
21735                 ndr->depth++;
21736                 if (r->in.environment) {
21737                         ndr_print_string(ndr, "environment", r->in.environment);
21738                 }
21739                 ndr->depth--;
21740                 ndr_print_uint32(ndr, "level", r->in.level);
21741                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21742                 ndr->depth++;
21743                 if (r->in.buffer) {
21744                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21745                 }
21746                 ndr->depth--;
21747                 ndr_print_uint32(ndr, "offered", r->in.offered);
21748                 ndr->depth--;
21749         }
21750         if (flags & NDR_OUT) {
21751                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
21752                 ndr->depth++;
21753                 ndr_print_ptr(ndr, "count", r->out.count);
21754                 ndr->depth++;
21755                 ndr_print_uint32(ndr, "count", *r->out.count);
21756                 ndr->depth--;
21757                 ndr_print_ptr(ndr, "info", r->out.info);
21758                 ndr->depth++;
21759                 ndr_print_ptr(ndr, "info", *r->out.info);
21760                 ndr->depth++;
21761                 if (*r->out.info) {
21762                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21763                         ndr->depth++;
21764                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21765                                 char *idx_2=NULL;
21766                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21767                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21768                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21769                                         free(idx_2);
21770                                 }
21771                         }
21772                         ndr->depth--;
21773                 }
21774                 ndr->depth--;
21775                 ndr->depth--;
21776                 ndr_print_ptr(ndr, "needed", r->out.needed);
21777                 ndr->depth++;
21778                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21779                 ndr->depth--;
21780                 ndr_print_WERROR(ndr, "result", r->out.result);
21781                 ndr->depth--;
21782         }
21783         ndr->depth--;
21784 }
21785
21786 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21787 {
21788         if (flags & NDR_IN) {
21789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21790                 if (r->in.server) {
21791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21792                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21793                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21794                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21795                 }
21796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21797                 if (r->in.environment) {
21798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21799                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21801                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21802                 }
21803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21805                 if (r->in.buffer) {
21806                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21807                 }
21808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21809         }
21810         if (flags & NDR_OUT) {
21811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21812                 if (r->out.info) {
21813                         {
21814                                 struct ndr_push *_ndr_info;
21815                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21816                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21817                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21818                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21819                         }
21820                 }
21821                 if (r->out.needed == NULL) {
21822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21823                 }
21824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21825                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21826         }
21827         return NDR_ERR_SUCCESS;
21828 }
21829
21830 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
21831 {
21832         uint32_t _ptr_server;
21833         uint32_t _ptr_environment;
21834         uint32_t _ptr_buffer;
21835         uint32_t _ptr_info;
21836         TALLOC_CTX *_mem_save_server_0;
21837         TALLOC_CTX *_mem_save_environment_0;
21838         TALLOC_CTX *_mem_save_buffer_0;
21839         TALLOC_CTX *_mem_save_info_0;
21840         TALLOC_CTX *_mem_save_needed_0;
21841         if (flags & NDR_IN) {
21842                 ZERO_STRUCT(r->out);
21843
21844                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21845                 if (_ptr_server) {
21846                         NDR_PULL_ALLOC(ndr, r->in.server);
21847                 } else {
21848                         r->in.server = NULL;
21849                 }
21850                 if (r->in.server) {
21851                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21852                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21853                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21854                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21855                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21856                                 return 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));
21857                         }
21858                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21859                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21861                 }
21862                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21863                 if (_ptr_environment) {
21864                         NDR_PULL_ALLOC(ndr, r->in.environment);
21865                 } else {
21866                         r->in.environment = NULL;
21867                 }
21868                 if (r->in.environment) {
21869                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21870                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21871                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21872                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21873                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21874                                 return 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));
21875                         }
21876                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21877                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21879                 }
21880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21882                 if (_ptr_buffer) {
21883                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21884                 } else {
21885                         r->in.buffer = NULL;
21886                 }
21887                 if (r->in.buffer) {
21888                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21889                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21890                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21891                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21892                 }
21893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21894                 NDR_PULL_ALLOC(ndr, r->out.needed);
21895                 ZERO_STRUCTP(r->out.needed);
21896         }
21897         if (flags & NDR_OUT) {
21898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21899                 if (_ptr_info) {
21900                         NDR_PULL_ALLOC(ndr, r->out.info);
21901                 } else {
21902                         r->out.info = NULL;
21903                 }
21904                 if (r->out.info) {
21905                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21906                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21907                         {
21908                                 struct ndr_pull *_ndr_info;
21909                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21910                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21911                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21912                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21913                         }
21914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21915                 }
21916                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21917                         NDR_PULL_ALLOC(ndr, r->out.needed);
21918                 }
21919                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21920                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21922                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21923                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21924         }
21925         return NDR_ERR_SUCCESS;
21926 }
21927
21928 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21929 {
21930         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
21931         ndr->depth++;
21932         if (flags & NDR_SET_VALUES) {
21933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21934         }
21935         if (flags & NDR_IN) {
21936                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
21937                 ndr->depth++;
21938                 ndr_print_ptr(ndr, "server", r->in.server);
21939                 ndr->depth++;
21940                 if (r->in.server) {
21941                         ndr_print_string(ndr, "server", r->in.server);
21942                 }
21943                 ndr->depth--;
21944                 ndr_print_ptr(ndr, "environment", r->in.environment);
21945                 ndr->depth++;
21946                 if (r->in.environment) {
21947                         ndr_print_string(ndr, "environment", r->in.environment);
21948                 }
21949                 ndr->depth--;
21950                 ndr_print_uint32(ndr, "level", r->in.level);
21951                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21952                 ndr->depth++;
21953                 if (r->in.buffer) {
21954                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21955                 }
21956                 ndr->depth--;
21957                 ndr_print_uint32(ndr, "offered", r->in.offered);
21958                 ndr->depth--;
21959         }
21960         if (flags & NDR_OUT) {
21961                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
21962                 ndr->depth++;
21963                 ndr_print_ptr(ndr, "info", r->out.info);
21964                 ndr->depth++;
21965                 if (r->out.info) {
21966                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21967                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
21968                 }
21969                 ndr->depth--;
21970                 ndr_print_ptr(ndr, "needed", r->out.needed);
21971                 ndr->depth++;
21972                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21973                 ndr->depth--;
21974                 ndr_print_WERROR(ndr, "result", r->out.result);
21975                 ndr->depth--;
21976         }
21977         ndr->depth--;
21978 }
21979
21980 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
21981 {
21982         if (flags & NDR_IN) {
21983                 if (r->in.handle == NULL) {
21984                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21985                 }
21986                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21988                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21989                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21990         }
21991         if (flags & NDR_OUT) {
21992                 if (r->out.job_id == NULL) {
21993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21994                 }
21995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
21996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21997         }
21998         return NDR_ERR_SUCCESS;
21999 }
22000
22001 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
22002 {
22003         TALLOC_CTX *_mem_save_handle_0;
22004         TALLOC_CTX *_mem_save_job_id_0;
22005         if (flags & NDR_IN) {
22006                 ZERO_STRUCT(r->out);
22007
22008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22009                         NDR_PULL_ALLOC(ndr, r->in.handle);
22010                 }
22011                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22012                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22013                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22016                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22017                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22018                 NDR_PULL_ALLOC(ndr, r->out.job_id);
22019                 ZERO_STRUCTP(r->out.job_id);
22020         }
22021         if (flags & NDR_OUT) {
22022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22023                         NDR_PULL_ALLOC(ndr, r->out.job_id);
22024                 }
22025                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
22026                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
22027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
22028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
22029                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22030         }
22031         return NDR_ERR_SUCCESS;
22032 }
22033
22034 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
22035 {
22036         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
22037         ndr->depth++;
22038         if (flags & NDR_SET_VALUES) {
22039                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22040         }
22041         if (flags & NDR_IN) {
22042                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
22043                 ndr->depth++;
22044                 ndr_print_ptr(ndr, "handle", r->in.handle);
22045                 ndr->depth++;
22046                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22047                 ndr->depth--;
22048                 ndr_print_uint32(ndr, "level", r->in.level);
22049                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22050                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
22051                 ndr->depth--;
22052         }
22053         if (flags & NDR_OUT) {
22054                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
22055                 ndr->depth++;
22056                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
22057                 ndr->depth++;
22058                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
22059                 ndr->depth--;
22060                 ndr_print_WERROR(ndr, "result", r->out.result);
22061                 ndr->depth--;
22062         }
22063         ndr->depth--;
22064 }
22065
22066 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
22067 {
22068         if (flags & NDR_IN) {
22069                 if (r->in.handle == NULL) {
22070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22071                 }
22072                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22073         }
22074         if (flags & NDR_OUT) {
22075                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22076         }
22077         return NDR_ERR_SUCCESS;
22078 }
22079
22080 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22081 {
22082         TALLOC_CTX *_mem_save_handle_0;
22083         if (flags & NDR_IN) {
22084                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22085                         NDR_PULL_ALLOC(ndr, r->in.handle);
22086                 }
22087                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22088                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22089                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22090                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22091         }
22092         if (flags & NDR_OUT) {
22093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22094         }
22095         return NDR_ERR_SUCCESS;
22096 }
22097
22098 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22099 {
22100         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22101         ndr->depth++;
22102         if (flags & NDR_SET_VALUES) {
22103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22104         }
22105         if (flags & NDR_IN) {
22106                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
22107                 ndr->depth++;
22108                 ndr_print_ptr(ndr, "handle", r->in.handle);
22109                 ndr->depth++;
22110                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22111                 ndr->depth--;
22112                 ndr->depth--;
22113         }
22114         if (flags & NDR_OUT) {
22115                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
22116                 ndr->depth++;
22117                 ndr_print_WERROR(ndr, "result", r->out.result);
22118                 ndr->depth--;
22119         }
22120         ndr->depth--;
22121 }
22122
22123 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
22124 {
22125         if (flags & NDR_IN) {
22126                 if (r->in.handle == NULL) {
22127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22128                 }
22129                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22130                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
22132         }
22133         if (flags & NDR_OUT) {
22134                 if (r->out.num_written == NULL) {
22135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22136                 }
22137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
22138                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22139         }
22140         return NDR_ERR_SUCCESS;
22141 }
22142
22143 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
22144 {
22145         TALLOC_CTX *_mem_save_handle_0;
22146         TALLOC_CTX *_mem_save_num_written_0;
22147         if (flags & NDR_IN) {
22148                 ZERO_STRUCT(r->out);
22149
22150                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22151                         NDR_PULL_ALLOC(ndr, r->in.handle);
22152                 }
22153                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22154                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22155                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22157                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
22158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
22159                 NDR_PULL_ALLOC(ndr, r->out.num_written);
22160                 ZERO_STRUCTP(r->out.num_written);
22161         }
22162         if (flags & NDR_OUT) {
22163                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22164                         NDR_PULL_ALLOC(ndr, r->out.num_written);
22165                 }
22166                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
22167                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
22168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
22169                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
22170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22171         }
22172         return NDR_ERR_SUCCESS;
22173 }
22174
22175 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
22176 {
22177         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
22178         ndr->depth++;
22179         if (flags & NDR_SET_VALUES) {
22180                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22181         }
22182         if (flags & NDR_IN) {
22183                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
22184                 ndr->depth++;
22185                 ndr_print_ptr(ndr, "handle", r->in.handle);
22186                 ndr->depth++;
22187                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22188                 ndr->depth--;
22189                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
22190                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
22191                 ndr->depth--;
22192         }
22193         if (flags & NDR_OUT) {
22194                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
22195                 ndr->depth++;
22196                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
22197                 ndr->depth++;
22198                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
22199                 ndr->depth--;
22200                 ndr_print_WERROR(ndr, "result", r->out.result);
22201                 ndr->depth--;
22202         }
22203         ndr->depth--;
22204 }
22205
22206 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
22207 {
22208         if (flags & NDR_IN) {
22209                 if (r->in.handle == NULL) {
22210                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22211                 }
22212                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22213         }
22214         if (flags & NDR_OUT) {
22215                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22216         }
22217         return NDR_ERR_SUCCESS;
22218 }
22219
22220 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
22221 {
22222         TALLOC_CTX *_mem_save_handle_0;
22223         if (flags & NDR_IN) {
22224                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22225                         NDR_PULL_ALLOC(ndr, r->in.handle);
22226                 }
22227                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22228                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22229                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22230                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22231         }
22232         if (flags & NDR_OUT) {
22233                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22234         }
22235         return NDR_ERR_SUCCESS;
22236 }
22237
22238 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
22239 {
22240         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
22241         ndr->depth++;
22242         if (flags & NDR_SET_VALUES) {
22243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22244         }
22245         if (flags & NDR_IN) {
22246                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
22247                 ndr->depth++;
22248                 ndr_print_ptr(ndr, "handle", r->in.handle);
22249                 ndr->depth++;
22250                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22251                 ndr->depth--;
22252                 ndr->depth--;
22253         }
22254         if (flags & NDR_OUT) {
22255                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
22256                 ndr->depth++;
22257                 ndr_print_WERROR(ndr, "result", r->out.result);
22258                 ndr->depth--;
22259         }
22260         ndr->depth--;
22261 }
22262
22263 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
22264 {
22265         if (flags & NDR_IN) {
22266                 if (r->in.handle == NULL) {
22267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22268                 }
22269                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22270         }
22271         if (flags & NDR_OUT) {
22272                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22273         }
22274         return NDR_ERR_SUCCESS;
22275 }
22276
22277 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
22278 {
22279         TALLOC_CTX *_mem_save_handle_0;
22280         if (flags & NDR_IN) {
22281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22282                         NDR_PULL_ALLOC(ndr, r->in.handle);
22283                 }
22284                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22285                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22286                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22287                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22288         }
22289         if (flags & NDR_OUT) {
22290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22291         }
22292         return NDR_ERR_SUCCESS;
22293 }
22294
22295 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
22296 {
22297         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
22298         ndr->depth++;
22299         if (flags & NDR_SET_VALUES) {
22300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22301         }
22302         if (flags & NDR_IN) {
22303                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
22304                 ndr->depth++;
22305                 ndr_print_ptr(ndr, "handle", r->in.handle);
22306                 ndr->depth++;
22307                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22308                 ndr->depth--;
22309                 ndr->depth--;
22310         }
22311         if (flags & NDR_OUT) {
22312                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
22313                 ndr->depth++;
22314                 ndr_print_WERROR(ndr, "result", r->out.result);
22315                 ndr->depth--;
22316         }
22317         ndr->depth--;
22318 }
22319
22320 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
22321 {
22322         if (flags & NDR_IN) {
22323                 if (r->in.handle == NULL) {
22324                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22325                 }
22326                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
22328         }
22329         if (flags & NDR_OUT) {
22330                 if (r->out.data == NULL) {
22331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22332                 }
22333                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
22334                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
22335                 if (r->out._data_size == NULL) {
22336                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22337                 }
22338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
22339                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22340         }
22341         return NDR_ERR_SUCCESS;
22342 }
22343
22344 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
22345 {
22346         TALLOC_CTX *_mem_save_handle_0;
22347         TALLOC_CTX *_mem_save__data_size_0;
22348         if (flags & NDR_IN) {
22349                 ZERO_STRUCT(r->out);
22350
22351                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22352                         NDR_PULL_ALLOC(ndr, r->in.handle);
22353                 }
22354                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22355                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22356                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22357                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
22359                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
22360                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
22361                 NDR_PULL_ALLOC(ndr, r->out._data_size);
22362                 ZERO_STRUCTP(r->out._data_size);
22363         }
22364         if (flags & NDR_OUT) {
22365                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
22366                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22367                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
22368                 }
22369                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
22370                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22371                         NDR_PULL_ALLOC(ndr, r->out._data_size);
22372                 }
22373                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
22374                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
22375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
22376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
22377                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22378                 if (r->out.data) {
22379                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
22380                 }
22381         }
22382         return NDR_ERR_SUCCESS;
22383 }
22384
22385 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
22386 {
22387         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
22388         ndr->depth++;
22389         if (flags & NDR_SET_VALUES) {
22390                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22391         }
22392         if (flags & NDR_IN) {
22393                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
22394                 ndr->depth++;
22395                 ndr_print_ptr(ndr, "handle", r->in.handle);
22396                 ndr->depth++;
22397                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22398                 ndr->depth--;
22399                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
22400                 ndr->depth--;
22401         }
22402         if (flags & NDR_OUT) {
22403                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
22404                 ndr->depth++;
22405                 ndr_print_ptr(ndr, "data", r->out.data);
22406                 ndr->depth++;
22407                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
22408                 ndr->depth--;
22409                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
22410                 ndr->depth++;
22411                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
22412                 ndr->depth--;
22413                 ndr_print_WERROR(ndr, "result", r->out.result);
22414                 ndr->depth--;
22415         }
22416         ndr->depth--;
22417 }
22418
22419 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
22420 {
22421         if (flags & NDR_IN) {
22422                 if (r->in.handle == NULL) {
22423                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22424                 }
22425                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22426         }
22427         if (flags & NDR_OUT) {
22428                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22429         }
22430         return NDR_ERR_SUCCESS;
22431 }
22432
22433 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
22434 {
22435         TALLOC_CTX *_mem_save_handle_0;
22436         if (flags & NDR_IN) {
22437                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22438                         NDR_PULL_ALLOC(ndr, r->in.handle);
22439                 }
22440                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22441                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22442                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22443                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22444         }
22445         if (flags & NDR_OUT) {
22446                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22447         }
22448         return NDR_ERR_SUCCESS;
22449 }
22450
22451 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
22452 {
22453         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
22454         ndr->depth++;
22455         if (flags & NDR_SET_VALUES) {
22456                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22457         }
22458         if (flags & NDR_IN) {
22459                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
22460                 ndr->depth++;
22461                 ndr_print_ptr(ndr, "handle", r->in.handle);
22462                 ndr->depth++;
22463                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22464                 ndr->depth--;
22465                 ndr->depth--;
22466         }
22467         if (flags & NDR_OUT) {
22468                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
22469                 ndr->depth++;
22470                 ndr_print_WERROR(ndr, "result", r->out.result);
22471                 ndr->depth--;
22472         }
22473         ndr->depth--;
22474 }
22475
22476 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
22477 {
22478         if (flags & NDR_IN) {
22479                 if (r->in.handle == NULL) {
22480                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22481                 }
22482                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22484                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22485                 if (r->in.buffer) {
22486                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
22487                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
22488                 }
22489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22490         }
22491         if (flags & NDR_OUT) {
22492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
22493                 if (r->out.buffer) {
22494                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
22495                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
22496                 }
22497                 if (r->out.needed == NULL) {
22498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22499                 }
22500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22501                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22502         }
22503         return NDR_ERR_SUCCESS;
22504 }
22505
22506 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
22507 {
22508         uint32_t _ptr_buffer;
22509         TALLOC_CTX *_mem_save_handle_0;
22510         TALLOC_CTX *_mem_save_buffer_0;
22511         TALLOC_CTX *_mem_save_needed_0;
22512         if (flags & NDR_IN) {
22513                 ZERO_STRUCT(r->out);
22514
22515                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22516                         NDR_PULL_ALLOC(ndr, r->in.handle);
22517                 }
22518                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22519                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22520                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22523                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22524                 if (_ptr_buffer) {
22525                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22526                 } else {
22527                         r->in.buffer = NULL;
22528                 }
22529                 if (r->in.buffer) {
22530                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22531                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22532                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
22533                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
22534                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
22535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22536                 }
22537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22538                 NDR_PULL_ALLOC(ndr, r->out.needed);
22539                 ZERO_STRUCTP(r->out.needed);
22540                 if (r->in.buffer) {
22541                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
22542                 }
22543         }
22544         if (flags & NDR_OUT) {
22545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22546                 if (_ptr_buffer) {
22547                         NDR_PULL_ALLOC(ndr, r->out.buffer);
22548                 } else {
22549                         r->out.buffer = NULL;
22550                 }
22551                 if (r->out.buffer) {
22552                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22553                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
22554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
22555                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
22556                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
22557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22558                 }
22559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22560                         NDR_PULL_ALLOC(ndr, r->out.needed);
22561                 }
22562                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22563                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22566                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22567                 if (r->out.buffer) {
22568                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
22569                 }
22570         }
22571         return NDR_ERR_SUCCESS;
22572 }
22573
22574 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
22575 {
22576         ndr_print_struct(ndr, name, "spoolss_AddJob");
22577         ndr->depth++;
22578         if (flags & NDR_SET_VALUES) {
22579                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22580         }
22581         if (flags & NDR_IN) {
22582                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
22583                 ndr->depth++;
22584                 ndr_print_ptr(ndr, "handle", r->in.handle);
22585                 ndr->depth++;
22586                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22587                 ndr->depth--;
22588                 ndr_print_uint32(ndr, "level", r->in.level);
22589                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22590                 ndr->depth++;
22591                 if (r->in.buffer) {
22592                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
22593                 }
22594                 ndr->depth--;
22595                 ndr_print_uint32(ndr, "offered", r->in.offered);
22596                 ndr->depth--;
22597         }
22598         if (flags & NDR_OUT) {
22599                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
22600                 ndr->depth++;
22601                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
22602                 ndr->depth++;
22603                 if (r->out.buffer) {
22604                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
22605                 }
22606                 ndr->depth--;
22607                 ndr_print_ptr(ndr, "needed", r->out.needed);
22608                 ndr->depth++;
22609                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22610                 ndr->depth--;
22611                 ndr_print_WERROR(ndr, "result", r->out.result);
22612                 ndr->depth--;
22613         }
22614         ndr->depth--;
22615 }
22616
22617 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
22618 {
22619         if (flags & NDR_IN) {
22620                 if (r->in.handle == NULL) {
22621                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22622                 }
22623                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
22625         }
22626         if (flags & NDR_OUT) {
22627                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22628         }
22629         return NDR_ERR_SUCCESS;
22630 }
22631
22632 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
22633 {
22634         TALLOC_CTX *_mem_save_handle_0;
22635         if (flags & NDR_IN) {
22636                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22637                         NDR_PULL_ALLOC(ndr, r->in.handle);
22638                 }
22639                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22640                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22641                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22642                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
22644         }
22645         if (flags & NDR_OUT) {
22646                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22647         }
22648         return NDR_ERR_SUCCESS;
22649 }
22650
22651 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
22652 {
22653         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
22654         ndr->depth++;
22655         if (flags & NDR_SET_VALUES) {
22656                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22657         }
22658         if (flags & NDR_IN) {
22659                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
22660                 ndr->depth++;
22661                 ndr_print_ptr(ndr, "handle", r->in.handle);
22662                 ndr->depth++;
22663                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22664                 ndr->depth--;
22665                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
22666                 ndr->depth--;
22667         }
22668         if (flags & NDR_OUT) {
22669                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
22670                 ndr->depth++;
22671                 ndr_print_WERROR(ndr, "result", r->out.result);
22672                 ndr->depth--;
22673         }
22674         ndr->depth--;
22675 }
22676
22677 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
22678 {
22679         if (flags & NDR_IN) {
22680                 if (r->in.handle == NULL) {
22681                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22682                 }
22683                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22684                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22685                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22686                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22687                 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));
22688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22689         }
22690         if (flags & NDR_OUT) {
22691                 if (r->out.type == NULL) {
22692                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22693                 }
22694                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
22695                 if (r->out.data == NULL) {
22696                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22697                 }
22698                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
22699                 if (r->out.needed == NULL) {
22700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22701                 }
22702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22703                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22704         }
22705         return NDR_ERR_SUCCESS;
22706 }
22707
22708 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
22709 {
22710         TALLOC_CTX *_mem_save_handle_0;
22711         TALLOC_CTX *_mem_save_type_0;
22712         TALLOC_CTX *_mem_save_data_0;
22713         TALLOC_CTX *_mem_save_needed_0;
22714         if (flags & NDR_IN) {
22715                 ZERO_STRUCT(r->out);
22716
22717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22718                         NDR_PULL_ALLOC(ndr, r->in.handle);
22719                 }
22720                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22721                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22722                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22724                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22725                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22726                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
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.value_name), ndr_get_array_length(ndr, &r->in.value_name));
22728                 }
22729                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22730                 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));
22731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22732                 NDR_PULL_ALLOC(ndr, r->out.type);
22733                 ZERO_STRUCTP(r->out.type);
22734                 NDR_PULL_ALLOC(ndr, r->out.data);
22735                 ZERO_STRUCTP(r->out.data);
22736                 NDR_PULL_ALLOC(ndr, r->out.needed);
22737                 ZERO_STRUCTP(r->out.needed);
22738         }
22739         if (flags & NDR_OUT) {
22740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22741                         NDR_PULL_ALLOC(ndr, r->out.type);
22742                 }
22743                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
22744                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
22745                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
22746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
22747                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22748                         NDR_PULL_ALLOC(ndr, r->out.data);
22749                 }
22750                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22751                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22752                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
22753                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22754                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22755                         NDR_PULL_ALLOC(ndr, r->out.needed);
22756                 }
22757                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22758                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22759                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22760                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22761                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22762         }
22763         return NDR_ERR_SUCCESS;
22764 }
22765
22766 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
22767 {
22768         if (flags & NDR_IN) {
22769                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22770         }
22771         if (flags & NDR_OUT) {
22772                 if (r->out.data == NULL) {
22773                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22774                 }
22775                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22776                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22777         }
22778         return NDR_ERR_SUCCESS;
22779 }
22780
22781 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
22782 {
22783         TALLOC_CTX *_mem_save_data_0;
22784         if (flags & NDR_IN) {
22785                 ZERO_STRUCT(r->out);
22786
22787                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22788                 NDR_PULL_ALLOC(ndr, r->out.data);
22789                 ZERO_STRUCTP(r->out.data);
22790         }
22791         if (flags & NDR_OUT) {
22792                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22793                         NDR_PULL_ALLOC(ndr, r->out.data);
22794                 }
22795                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22796                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22797                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
22798                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22799                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22800         }
22801         return NDR_ERR_SUCCESS;
22802 }
22803
22804 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
22805 {
22806         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
22807         ndr->depth++;
22808         if (flags & NDR_SET_VALUES) {
22809                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22810         }
22811         if (flags & NDR_IN) {
22812                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
22813                 ndr->depth++;
22814                 ndr_print_ptr(ndr, "handle", r->in.handle);
22815                 ndr->depth++;
22816                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22817                 ndr->depth--;
22818                 ndr_print_string(ndr, "value_name", r->in.value_name);
22819                 ndr_print_uint32(ndr, "offered", r->in.offered);
22820                 ndr->depth--;
22821         }
22822         if (flags & NDR_OUT) {
22823                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
22824                 ndr->depth++;
22825                 ndr_print_ptr(ndr, "type", r->out.type);
22826                 ndr->depth++;
22827                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
22828                 ndr->depth--;
22829                 ndr_print_ptr(ndr, "data", r->out.data);
22830                 ndr->depth++;
22831                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
22832                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
22833                 ndr->depth--;
22834                 ndr_print_ptr(ndr, "needed", r->out.needed);
22835                 ndr->depth++;
22836                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22837                 ndr->depth--;
22838                 ndr_print_WERROR(ndr, "result", r->out.result);
22839                 ndr->depth--;
22840         }
22841         ndr->depth--;
22842 }
22843
22844 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
22845 {
22846         if (flags & NDR_IN) {
22847                 if (r->in.handle == NULL) {
22848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22849                 }
22850                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22851                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22852                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22853                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22854                 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));
22855                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22856                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
22858         }
22859         if (flags & NDR_OUT) {
22860                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22861         }
22862         return NDR_ERR_SUCCESS;
22863 }
22864
22865 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
22866 {
22867         if (flags & NDR_IN) {
22868                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22869         }
22870         if (flags & NDR_OUT) {
22871                 if (r->out.data == NULL) {
22872                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22873                 }
22874                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22875                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22876         }
22877         return NDR_ERR_SUCCESS;
22878 }
22879
22880 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
22881 {
22882         TALLOC_CTX *_mem_save_handle_0;
22883         if (flags & NDR_IN) {
22884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22885                         NDR_PULL_ALLOC(ndr, r->in.handle);
22886                 }
22887                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22888                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22889                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22891                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22892                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22893                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22894                         return 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));
22895                 }
22896                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22897                 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));
22898                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22899                 {
22900                         struct ndr_pull *_ndr_data;
22901                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
22902                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
22903                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
22904                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
22905                 }
22906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
22907         }
22908         if (flags & NDR_OUT) {
22909                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22910         }
22911         return NDR_ERR_SUCCESS;
22912 }
22913
22914 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
22915 {
22916         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
22917         ndr->depth++;
22918         if (flags & NDR_SET_VALUES) {
22919                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22920         }
22921         if (flags & NDR_IN) {
22922                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
22923                 ndr->depth++;
22924                 ndr_print_ptr(ndr, "handle", r->in.handle);
22925                 ndr->depth++;
22926                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22927                 ndr->depth--;
22928                 ndr_print_string(ndr, "value_name", r->in.value_name);
22929                 ndr_print_winreg_Type(ndr, "type", r->in.type);
22930                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
22931                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
22932                 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);
22933                 ndr->depth--;
22934         }
22935         if (flags & NDR_OUT) {
22936                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
22937                 ndr->depth++;
22938                 ndr_print_WERROR(ndr, "result", r->out.result);
22939                 ndr->depth--;
22940         }
22941         ndr->depth--;
22942 }
22943
22944 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
22945 {
22946         if (flags & NDR_IN) {
22947         }
22948         if (flags & NDR_OUT) {
22949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22950         }
22951         return NDR_ERR_SUCCESS;
22952 }
22953
22954 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
22955 {
22956         if (flags & NDR_IN) {
22957         }
22958         if (flags & NDR_OUT) {
22959                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22960         }
22961         return NDR_ERR_SUCCESS;
22962 }
22963
22964 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
22965 {
22966         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
22967         ndr->depth++;
22968         if (flags & NDR_SET_VALUES) {
22969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22970         }
22971         if (flags & NDR_IN) {
22972                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
22973                 ndr->depth++;
22974                 ndr->depth--;
22975         }
22976         if (flags & NDR_OUT) {
22977                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
22978                 ndr->depth++;
22979                 ndr_print_WERROR(ndr, "result", r->out.result);
22980                 ndr->depth--;
22981         }
22982         ndr->depth--;
22983 }
22984
22985 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
22986 {
22987         if (flags & NDR_IN) {
22988                 if (r->in.handle == NULL) {
22989                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22990                 }
22991                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22992         }
22993         if (flags & NDR_OUT) {
22994                 if (r->out.handle == NULL) {
22995                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22996                 }
22997                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22998                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22999         }
23000         return NDR_ERR_SUCCESS;
23001 }
23002
23003 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
23004 {
23005         TALLOC_CTX *_mem_save_handle_0;
23006         if (flags & NDR_IN) {
23007                 ZERO_STRUCT(r->out);
23008
23009                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23010                         NDR_PULL_ALLOC(ndr, r->in.handle);
23011                 }
23012                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23013                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23014                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23016                 NDR_PULL_ALLOC(ndr, r->out.handle);
23017                 *r->out.handle = *r->in.handle;
23018         }
23019         if (flags & NDR_OUT) {
23020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23021                         NDR_PULL_ALLOC(ndr, r->out.handle);
23022                 }
23023                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23025                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23027                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23028         }
23029         return NDR_ERR_SUCCESS;
23030 }
23031
23032 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
23033 {
23034         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
23035         ndr->depth++;
23036         if (flags & NDR_SET_VALUES) {
23037                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23038         }
23039         if (flags & NDR_IN) {
23040                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
23041                 ndr->depth++;
23042                 ndr_print_ptr(ndr, "handle", r->in.handle);
23043                 ndr->depth++;
23044                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23045                 ndr->depth--;
23046                 ndr->depth--;
23047         }
23048         if (flags & NDR_OUT) {
23049                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
23050                 ndr->depth++;
23051                 ndr_print_ptr(ndr, "handle", r->out.handle);
23052                 ndr->depth++;
23053                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23054                 ndr->depth--;
23055                 ndr_print_WERROR(ndr, "result", r->out.result);
23056                 ndr->depth--;
23057         }
23058         ndr->depth--;
23059 }
23060
23061 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
23062 {
23063         if (flags & NDR_IN) {
23064                 if (r->in.handle == NULL) {
23065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23066                 }
23067                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23069                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23070                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23071         }
23072         if (flags & NDR_OUT) {
23073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23074         }
23075         return NDR_ERR_SUCCESS;
23076 }
23077
23078 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23079 {
23080         TALLOC_CTX *_mem_save_handle_0;
23081         if (flags & NDR_IN) {
23082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23083                         NDR_PULL_ALLOC(ndr, r->in.handle);
23084                 }
23085                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23086                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23087                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23090                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23091                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23092         }
23093         if (flags & NDR_OUT) {
23094                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23095         }
23096         return NDR_ERR_SUCCESS;
23097 }
23098
23099 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23100 {
23101         ndr_print_struct(ndr, name, "spoolss_AddForm");
23102         ndr->depth++;
23103         if (flags & NDR_SET_VALUES) {
23104                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23105         }
23106         if (flags & NDR_IN) {
23107                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
23108                 ndr->depth++;
23109                 ndr_print_ptr(ndr, "handle", r->in.handle);
23110                 ndr->depth++;
23111                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23112                 ndr->depth--;
23113                 ndr_print_uint32(ndr, "level", r->in.level);
23114                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23115                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23116                 ndr->depth--;
23117         }
23118         if (flags & NDR_OUT) {
23119                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
23120                 ndr->depth++;
23121                 ndr_print_WERROR(ndr, "result", r->out.result);
23122                 ndr->depth--;
23123         }
23124         ndr->depth--;
23125 }
23126
23127 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
23128 {
23129         if (flags & NDR_IN) {
23130                 if (r->in.handle == NULL) {
23131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23132                 }
23133                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23134                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23135                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23136                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23137                 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));
23138         }
23139         if (flags & NDR_OUT) {
23140                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23141         }
23142         return NDR_ERR_SUCCESS;
23143 }
23144
23145 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
23146 {
23147         TALLOC_CTX *_mem_save_handle_0;
23148         if (flags & NDR_IN) {
23149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23150                         NDR_PULL_ALLOC(ndr, r->in.handle);
23151                 }
23152                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23153                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23154                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23156                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23157                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23158                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23159                         return 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));
23160                 }
23161                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23162                 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));
23163         }
23164         if (flags & NDR_OUT) {
23165                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23166         }
23167         return NDR_ERR_SUCCESS;
23168 }
23169
23170 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
23171 {
23172         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
23173         ndr->depth++;
23174         if (flags & NDR_SET_VALUES) {
23175                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23176         }
23177         if (flags & NDR_IN) {
23178                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
23179                 ndr->depth++;
23180                 ndr_print_ptr(ndr, "handle", r->in.handle);
23181                 ndr->depth++;
23182                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23183                 ndr->depth--;
23184                 ndr_print_string(ndr, "form_name", r->in.form_name);
23185                 ndr->depth--;
23186         }
23187         if (flags & NDR_OUT) {
23188                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
23189                 ndr->depth++;
23190                 ndr_print_WERROR(ndr, "result", r->out.result);
23191                 ndr->depth--;
23192         }
23193         ndr->depth--;
23194 }
23195
23196 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
23197 {
23198         if (flags & NDR_IN) {
23199                 if (r->in.handle == NULL) {
23200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23201                 }
23202                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23203                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23204                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23205                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23206                 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));
23207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23209                 if (r->in.buffer) {
23210                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23211                 }
23212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23213         }
23214         if (flags & NDR_OUT) {
23215                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23216                 if (r->out.info) {
23217                         {
23218                                 struct ndr_push *_ndr_info;
23219                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23220                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23221                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23222                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23223                         }
23224                 }
23225                 if (r->out.needed == NULL) {
23226                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23227                 }
23228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23229                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23230         }
23231         return NDR_ERR_SUCCESS;
23232 }
23233
23234 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
23235 {
23236         uint32_t _ptr_buffer;
23237         uint32_t _ptr_info;
23238         TALLOC_CTX *_mem_save_handle_0;
23239         TALLOC_CTX *_mem_save_buffer_0;
23240         TALLOC_CTX *_mem_save_info_0;
23241         TALLOC_CTX *_mem_save_needed_0;
23242         if (flags & NDR_IN) {
23243                 ZERO_STRUCT(r->out);
23244
23245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23246                         NDR_PULL_ALLOC(ndr, r->in.handle);
23247                 }
23248                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23249                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23250                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23252                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23253                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23254                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23255                         return 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));
23256                 }
23257                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23258                 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));
23259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23261                 if (_ptr_buffer) {
23262                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23263                 } else {
23264                         r->in.buffer = NULL;
23265                 }
23266                 if (r->in.buffer) {
23267                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23268                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23269                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23271                 }
23272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23273                 NDR_PULL_ALLOC(ndr, r->out.needed);
23274                 ZERO_STRUCTP(r->out.needed);
23275         }
23276         if (flags & NDR_OUT) {
23277                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23278                 if (_ptr_info) {
23279                         NDR_PULL_ALLOC(ndr, r->out.info);
23280                 } else {
23281                         r->out.info = NULL;
23282                 }
23283                 if (r->out.info) {
23284                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23285                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23286                         {
23287                                 struct ndr_pull *_ndr_info;
23288                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23289                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23290                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23291                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23292                         }
23293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23294                 }
23295                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23296                         NDR_PULL_ALLOC(ndr, r->out.needed);
23297                 }
23298                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23299                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23301                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23302                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23303         }
23304         return NDR_ERR_SUCCESS;
23305 }
23306
23307 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
23308 {
23309         ndr_print_struct(ndr, name, "spoolss_GetForm");
23310         ndr->depth++;
23311         if (flags & NDR_SET_VALUES) {
23312                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23313         }
23314         if (flags & NDR_IN) {
23315                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
23316                 ndr->depth++;
23317                 ndr_print_ptr(ndr, "handle", r->in.handle);
23318                 ndr->depth++;
23319                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23320                 ndr->depth--;
23321                 ndr_print_string(ndr, "form_name", r->in.form_name);
23322                 ndr_print_uint32(ndr, "level", r->in.level);
23323                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23324                 ndr->depth++;
23325                 if (r->in.buffer) {
23326                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23327                 }
23328                 ndr->depth--;
23329                 ndr_print_uint32(ndr, "offered", r->in.offered);
23330                 ndr->depth--;
23331         }
23332         if (flags & NDR_OUT) {
23333                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
23334                 ndr->depth++;
23335                 ndr_print_ptr(ndr, "info", r->out.info);
23336                 ndr->depth++;
23337                 if (r->out.info) {
23338                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23339                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
23340                 }
23341                 ndr->depth--;
23342                 ndr_print_ptr(ndr, "needed", r->out.needed);
23343                 ndr->depth++;
23344                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23345                 ndr->depth--;
23346                 ndr_print_WERROR(ndr, "result", r->out.result);
23347                 ndr->depth--;
23348         }
23349         ndr->depth--;
23350 }
23351
23352 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
23353 {
23354         if (flags & NDR_IN) {
23355                 if (r->in.handle == NULL) {
23356                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23357                 }
23358                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23359                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23360                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23361                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23362                 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));
23363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23364                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23365                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23366         }
23367         if (flags & NDR_OUT) {
23368                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23369         }
23370         return NDR_ERR_SUCCESS;
23371 }
23372
23373 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
23374 {
23375         TALLOC_CTX *_mem_save_handle_0;
23376         if (flags & NDR_IN) {
23377                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23378                         NDR_PULL_ALLOC(ndr, r->in.handle);
23379                 }
23380                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23381                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23382                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23383                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23384                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23385                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23386                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23387                         return 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));
23388                 }
23389                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23390                 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));
23391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23392                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23393                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23394         }
23395         if (flags & NDR_OUT) {
23396                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23397         }
23398         return NDR_ERR_SUCCESS;
23399 }
23400
23401 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
23402 {
23403         ndr_print_struct(ndr, name, "spoolss_SetForm");
23404         ndr->depth++;
23405         if (flags & NDR_SET_VALUES) {
23406                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23407         }
23408         if (flags & NDR_IN) {
23409                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
23410                 ndr->depth++;
23411                 ndr_print_ptr(ndr, "handle", r->in.handle);
23412                 ndr->depth++;
23413                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23414                 ndr->depth--;
23415                 ndr_print_string(ndr, "form_name", r->in.form_name);
23416                 ndr_print_uint32(ndr, "level", r->in.level);
23417                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23418                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23419                 ndr->depth--;
23420         }
23421         if (flags & NDR_OUT) {
23422                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
23423                 ndr->depth++;
23424                 ndr_print_WERROR(ndr, "result", r->out.result);
23425                 ndr->depth--;
23426         }
23427         ndr->depth--;
23428 }
23429
23430 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
23431 {
23432         if (flags & NDR_IN) {
23433                 if (r->in.handle == NULL) {
23434                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23435                 }
23436                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23439                 if (r->in.buffer) {
23440                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23441                 }
23442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23443         }
23444         if (flags & NDR_OUT) {
23445                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23446                 if (r->out.info) {
23447                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23448                 }
23449                 if (r->out.needed == NULL) {
23450                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23451                 }
23452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23453                 if (r->out.count == NULL) {
23454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23455                 }
23456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23457                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23458         }
23459         return NDR_ERR_SUCCESS;
23460 }
23461
23462 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
23463 {
23464         uint32_t _ptr_buffer;
23465         uint32_t _ptr_info;
23466         TALLOC_CTX *_mem_save_handle_0;
23467         TALLOC_CTX *_mem_save_buffer_0;
23468         TALLOC_CTX *_mem_save_info_0;
23469         TALLOC_CTX *_mem_save_needed_0;
23470         TALLOC_CTX *_mem_save_count_0;
23471         if (flags & NDR_IN) {
23472                 ZERO_STRUCT(r->out);
23473
23474                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23475                         NDR_PULL_ALLOC(ndr, r->in.handle);
23476                 }
23477                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23478                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23479                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23480                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23483                 if (_ptr_buffer) {
23484                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23485                 } else {
23486                         r->in.buffer = NULL;
23487                 }
23488                 if (r->in.buffer) {
23489                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23490                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23491                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23493                 }
23494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23495                 NDR_PULL_ALLOC(ndr, r->out.needed);
23496                 ZERO_STRUCTP(r->out.needed);
23497                 NDR_PULL_ALLOC(ndr, r->out.count);
23498                 ZERO_STRUCTP(r->out.count);
23499         }
23500         if (flags & NDR_OUT) {
23501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23502                 if (_ptr_info) {
23503                         NDR_PULL_ALLOC(ndr, r->out.info);
23504                 } else {
23505                         r->out.info = NULL;
23506                 }
23507                 if (r->out.info) {
23508                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23509                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23510                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23512                 }
23513                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23514                         NDR_PULL_ALLOC(ndr, r->out.needed);
23515                 }
23516                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23517                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23519                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23521                         NDR_PULL_ALLOC(ndr, r->out.count);
23522                 }
23523                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23524                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23527                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23528         }
23529         return NDR_ERR_SUCCESS;
23530 }
23531
23532 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
23533 {
23534         uint32_t cntr_info_0;
23535         if (flags & NDR_IN) {
23536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23538         }
23539         if (flags & NDR_OUT) {
23540                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23541                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23542                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23543                 }
23544                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23545                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23546                 }
23547         }
23548         return NDR_ERR_SUCCESS;
23549 }
23550
23551 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
23552 {
23553         uint32_t cntr_info_0;
23554         TALLOC_CTX *_mem_save_info_0;
23555         if (flags & NDR_IN) {
23556                 ZERO_STRUCT(r->out);
23557
23558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23560         }
23561         if (flags & NDR_OUT) {
23562                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23563                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23564                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23565                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23566                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23567                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23568                 }
23569                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23570                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23571                 }
23572                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23573         }
23574         return NDR_ERR_SUCCESS;
23575 }
23576
23577 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
23578 {
23579         uint32_t cntr_info_2;
23580         ndr_print_struct(ndr, name, "spoolss_EnumForms");
23581         ndr->depth++;
23582         if (flags & NDR_SET_VALUES) {
23583                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23584         }
23585         if (flags & NDR_IN) {
23586                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
23587                 ndr->depth++;
23588                 ndr_print_ptr(ndr, "handle", r->in.handle);
23589                 ndr->depth++;
23590                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23591                 ndr->depth--;
23592                 ndr_print_uint32(ndr, "level", r->in.level);
23593                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23594                 ndr->depth++;
23595                 if (r->in.buffer) {
23596                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23597                 }
23598                 ndr->depth--;
23599                 ndr_print_uint32(ndr, "offered", r->in.offered);
23600                 ndr->depth--;
23601         }
23602         if (flags & NDR_OUT) {
23603                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
23604                 ndr->depth++;
23605                 ndr_print_ptr(ndr, "count", r->out.count);
23606                 ndr->depth++;
23607                 ndr_print_uint32(ndr, "count", *r->out.count);
23608                 ndr->depth--;
23609                 ndr_print_ptr(ndr, "info", r->out.info);
23610                 ndr->depth++;
23611                 ndr_print_ptr(ndr, "info", *r->out.info);
23612                 ndr->depth++;
23613                 if (*r->out.info) {
23614                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23615                         ndr->depth++;
23616                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23617                                 char *idx_2=NULL;
23618                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23619                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23620                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23621                                         free(idx_2);
23622                                 }
23623                         }
23624                         ndr->depth--;
23625                 }
23626                 ndr->depth--;
23627                 ndr->depth--;
23628                 ndr_print_ptr(ndr, "needed", r->out.needed);
23629                 ndr->depth++;
23630                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23631                 ndr->depth--;
23632                 ndr_print_WERROR(ndr, "result", r->out.result);
23633                 ndr->depth--;
23634         }
23635         ndr->depth--;
23636 }
23637
23638 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
23639 {
23640         if (flags & NDR_IN) {
23641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23642                 if (r->in.servername) {
23643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23644                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23646                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23647                 }
23648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23650                 if (r->in.buffer) {
23651                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23652                 }
23653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23654         }
23655         if (flags & NDR_OUT) {
23656                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23657                 if (r->out.info) {
23658                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23659                 }
23660                 if (r->out.needed == NULL) {
23661                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23662                 }
23663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23664                 if (r->out.count == NULL) {
23665                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23666                 }
23667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23668                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23669         }
23670         return NDR_ERR_SUCCESS;
23671 }
23672
23673 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
23674 {
23675         uint32_t _ptr_servername;
23676         uint32_t _ptr_buffer;
23677         uint32_t _ptr_info;
23678         TALLOC_CTX *_mem_save_servername_0;
23679         TALLOC_CTX *_mem_save_buffer_0;
23680         TALLOC_CTX *_mem_save_info_0;
23681         TALLOC_CTX *_mem_save_needed_0;
23682         TALLOC_CTX *_mem_save_count_0;
23683         if (flags & NDR_IN) {
23684                 ZERO_STRUCT(r->out);
23685
23686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23687                 if (_ptr_servername) {
23688                         NDR_PULL_ALLOC(ndr, r->in.servername);
23689                 } else {
23690                         r->in.servername = NULL;
23691                 }
23692                 if (r->in.servername) {
23693                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23694                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23695                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23696                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23697                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23698                                 return 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));
23699                         }
23700                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23701                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23702                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23703                 }
23704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23706                 if (_ptr_buffer) {
23707                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23708                 } else {
23709                         r->in.buffer = NULL;
23710                 }
23711                 if (r->in.buffer) {
23712                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23713                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23714                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23716                 }
23717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23718                 NDR_PULL_ALLOC(ndr, r->out.needed);
23719                 ZERO_STRUCTP(r->out.needed);
23720                 NDR_PULL_ALLOC(ndr, r->out.count);
23721                 ZERO_STRUCTP(r->out.count);
23722         }
23723         if (flags & NDR_OUT) {
23724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23725                 if (_ptr_info) {
23726                         NDR_PULL_ALLOC(ndr, r->out.info);
23727                 } else {
23728                         r->out.info = NULL;
23729                 }
23730                 if (r->out.info) {
23731                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23732                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23733                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23734                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23735                 }
23736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23737                         NDR_PULL_ALLOC(ndr, r->out.needed);
23738                 }
23739                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23740                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23744                         NDR_PULL_ALLOC(ndr, r->out.count);
23745                 }
23746                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23747                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23749                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23750                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23751         }
23752         return NDR_ERR_SUCCESS;
23753 }
23754
23755 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
23756 {
23757         uint32_t cntr_info_0;
23758         if (flags & NDR_IN) {
23759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23761         }
23762         if (flags & NDR_OUT) {
23763                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23764                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23765                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23766                 }
23767                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23768                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23769                 }
23770         }
23771         return NDR_ERR_SUCCESS;
23772 }
23773
23774 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
23775 {
23776         uint32_t cntr_info_0;
23777         TALLOC_CTX *_mem_save_info_0;
23778         if (flags & NDR_IN) {
23779                 ZERO_STRUCT(r->out);
23780
23781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23783         }
23784         if (flags & NDR_OUT) {
23785                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23786                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23787                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23788                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23789                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23790                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23791                 }
23792                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23793                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23794                 }
23795                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23796         }
23797         return NDR_ERR_SUCCESS;
23798 }
23799
23800 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
23801 {
23802         uint32_t cntr_info_2;
23803         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
23804         ndr->depth++;
23805         if (flags & NDR_SET_VALUES) {
23806                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23807         }
23808         if (flags & NDR_IN) {
23809                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
23810                 ndr->depth++;
23811                 ndr_print_ptr(ndr, "servername", r->in.servername);
23812                 ndr->depth++;
23813                 if (r->in.servername) {
23814                         ndr_print_string(ndr, "servername", r->in.servername);
23815                 }
23816                 ndr->depth--;
23817                 ndr_print_uint32(ndr, "level", r->in.level);
23818                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23819                 ndr->depth++;
23820                 if (r->in.buffer) {
23821                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23822                 }
23823                 ndr->depth--;
23824                 ndr_print_uint32(ndr, "offered", r->in.offered);
23825                 ndr->depth--;
23826         }
23827         if (flags & NDR_OUT) {
23828                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
23829                 ndr->depth++;
23830                 ndr_print_ptr(ndr, "count", r->out.count);
23831                 ndr->depth++;
23832                 ndr_print_uint32(ndr, "count", *r->out.count);
23833                 ndr->depth--;
23834                 ndr_print_ptr(ndr, "info", r->out.info);
23835                 ndr->depth++;
23836                 ndr_print_ptr(ndr, "info", *r->out.info);
23837                 ndr->depth++;
23838                 if (*r->out.info) {
23839                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23840                         ndr->depth++;
23841                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23842                                 char *idx_2=NULL;
23843                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23844                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23845                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23846                                         free(idx_2);
23847                                 }
23848                         }
23849                         ndr->depth--;
23850                 }
23851                 ndr->depth--;
23852                 ndr->depth--;
23853                 ndr_print_ptr(ndr, "needed", r->out.needed);
23854                 ndr->depth++;
23855                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23856                 ndr->depth--;
23857                 ndr_print_WERROR(ndr, "result", r->out.result);
23858                 ndr->depth--;
23859         }
23860         ndr->depth--;
23861 }
23862
23863 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
23864 {
23865         if (flags & NDR_IN) {
23866                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23867                 if (r->in.servername) {
23868                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23872                 }
23873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23875                 if (r->in.buffer) {
23876                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23877                 }
23878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23879         }
23880         if (flags & NDR_OUT) {
23881                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23882                 if (r->out.info) {
23883                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23884                 }
23885                 if (r->out.needed == NULL) {
23886                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23887                 }
23888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23889                 if (r->out.count == NULL) {
23890                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23891                 }
23892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23893                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23894         }
23895         return NDR_ERR_SUCCESS;
23896 }
23897
23898 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
23899 {
23900         uint32_t _ptr_servername;
23901         uint32_t _ptr_buffer;
23902         uint32_t _ptr_info;
23903         TALLOC_CTX *_mem_save_servername_0;
23904         TALLOC_CTX *_mem_save_buffer_0;
23905         TALLOC_CTX *_mem_save_info_0;
23906         TALLOC_CTX *_mem_save_needed_0;
23907         TALLOC_CTX *_mem_save_count_0;
23908         if (flags & NDR_IN) {
23909                 ZERO_STRUCT(r->out);
23910
23911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23912                 if (_ptr_servername) {
23913                         NDR_PULL_ALLOC(ndr, r->in.servername);
23914                 } else {
23915                         r->in.servername = NULL;
23916                 }
23917                 if (r->in.servername) {
23918                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23919                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23921                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23922                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23923                                 return 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));
23924                         }
23925                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23926                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23928                 }
23929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23931                 if (_ptr_buffer) {
23932                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23933                 } else {
23934                         r->in.buffer = NULL;
23935                 }
23936                 if (r->in.buffer) {
23937                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23938                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23939                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23941                 }
23942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23943                 NDR_PULL_ALLOC(ndr, r->out.needed);
23944                 ZERO_STRUCTP(r->out.needed);
23945                 NDR_PULL_ALLOC(ndr, r->out.count);
23946                 ZERO_STRUCTP(r->out.count);
23947         }
23948         if (flags & NDR_OUT) {
23949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23950                 if (_ptr_info) {
23951                         NDR_PULL_ALLOC(ndr, r->out.info);
23952                 } else {
23953                         r->out.info = NULL;
23954                 }
23955                 if (r->out.info) {
23956                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23957                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23958                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23960                 }
23961                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23962                         NDR_PULL_ALLOC(ndr, r->out.needed);
23963                 }
23964                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23965                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23967                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23969                         NDR_PULL_ALLOC(ndr, r->out.count);
23970                 }
23971                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23972                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23975                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23976         }
23977         return NDR_ERR_SUCCESS;
23978 }
23979
23980 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
23981 {
23982         uint32_t cntr_info_0;
23983         if (flags & NDR_IN) {
23984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23986         }
23987         if (flags & NDR_OUT) {
23988                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23989                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23990                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23991                 }
23992                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23993                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23994                 }
23995         }
23996         return NDR_ERR_SUCCESS;
23997 }
23998
23999 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
24000 {
24001         uint32_t cntr_info_0;
24002         TALLOC_CTX *_mem_save_info_0;
24003         if (flags & NDR_IN) {
24004                 ZERO_STRUCT(r->out);
24005
24006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24008         }
24009         if (flags & NDR_OUT) {
24010                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24011                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24012                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24013                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24014                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24015                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24016                 }
24017                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24018                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24019                 }
24020                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24021         }
24022         return NDR_ERR_SUCCESS;
24023 }
24024
24025 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
24026 {
24027         uint32_t cntr_info_2;
24028         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
24029         ndr->depth++;
24030         if (flags & NDR_SET_VALUES) {
24031                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24032         }
24033         if (flags & NDR_IN) {
24034                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
24035                 ndr->depth++;
24036                 ndr_print_ptr(ndr, "servername", r->in.servername);
24037                 ndr->depth++;
24038                 if (r->in.servername) {
24039                         ndr_print_string(ndr, "servername", r->in.servername);
24040                 }
24041                 ndr->depth--;
24042                 ndr_print_uint32(ndr, "level", r->in.level);
24043                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24044                 ndr->depth++;
24045                 if (r->in.buffer) {
24046                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24047                 }
24048                 ndr->depth--;
24049                 ndr_print_uint32(ndr, "offered", r->in.offered);
24050                 ndr->depth--;
24051         }
24052         if (flags & NDR_OUT) {
24053                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
24054                 ndr->depth++;
24055                 ndr_print_ptr(ndr, "count", r->out.count);
24056                 ndr->depth++;
24057                 ndr_print_uint32(ndr, "count", *r->out.count);
24058                 ndr->depth--;
24059                 ndr_print_ptr(ndr, "info", r->out.info);
24060                 ndr->depth++;
24061                 ndr_print_ptr(ndr, "info", *r->out.info);
24062                 ndr->depth++;
24063                 if (*r->out.info) {
24064                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24065                         ndr->depth++;
24066                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24067                                 char *idx_2=NULL;
24068                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24069                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24070                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24071                                         free(idx_2);
24072                                 }
24073                         }
24074                         ndr->depth--;
24075                 }
24076                 ndr->depth--;
24077                 ndr->depth--;
24078                 ndr_print_ptr(ndr, "needed", r->out.needed);
24079                 ndr->depth++;
24080                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24081                 ndr->depth--;
24082                 ndr_print_WERROR(ndr, "result", r->out.result);
24083                 ndr->depth--;
24084         }
24085         ndr->depth--;
24086 }
24087
24088 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24089 {
24090         if (flags & NDR_IN) {
24091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24092                 if (r->in.server_name) {
24093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24095                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24096                         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));
24097                 }
24098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24099                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24100                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24101                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24102                 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));
24103         }
24104         if (flags & NDR_OUT) {
24105                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24106         }
24107         return NDR_ERR_SUCCESS;
24108 }
24109
24110 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
24111 {
24112         uint32_t _ptr_server_name;
24113         TALLOC_CTX *_mem_save_server_name_0;
24114         if (flags & NDR_IN) {
24115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
24116                 if (_ptr_server_name) {
24117                         NDR_PULL_ALLOC(ndr, r->in.server_name);
24118                 } else {
24119                         r->in.server_name = NULL;
24120                 }
24121                 if (r->in.server_name) {
24122                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24123                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
24124                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24125                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24126                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24127                                 return 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));
24128                         }
24129                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24130                         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));
24131                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
24132                 }
24133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
24134                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
24135                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
24136                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
24137                         return 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));
24138                 }
24139                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
24140                 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));
24141         }
24142         if (flags & NDR_OUT) {
24143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24144         }
24145         return NDR_ERR_SUCCESS;
24146 }
24147
24148 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
24149 {
24150         ndr_print_struct(ndr, name, "spoolss_AddPort");
24151         ndr->depth++;
24152         if (flags & NDR_SET_VALUES) {
24153                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24154         }
24155         if (flags & NDR_IN) {
24156                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
24157                 ndr->depth++;
24158                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
24159                 ndr->depth++;
24160                 if (r->in.server_name) {
24161                         ndr_print_string(ndr, "server_name", r->in.server_name);
24162                 }
24163                 ndr->depth--;
24164                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
24165                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
24166                 ndr->depth--;
24167         }
24168         if (flags & NDR_OUT) {
24169                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
24170                 ndr->depth++;
24171                 ndr_print_WERROR(ndr, "result", r->out.result);
24172                 ndr->depth--;
24173         }
24174         ndr->depth--;
24175 }
24176
24177 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
24178 {
24179         if (flags & NDR_IN) {
24180         }
24181         if (flags & NDR_OUT) {
24182                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24183         }
24184         return NDR_ERR_SUCCESS;
24185 }
24186
24187 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
24188 {
24189         if (flags & NDR_IN) {
24190         }
24191         if (flags & NDR_OUT) {
24192                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24193         }
24194         return NDR_ERR_SUCCESS;
24195 }
24196
24197 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
24198 {
24199         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
24200         ndr->depth++;
24201         if (flags & NDR_SET_VALUES) {
24202                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24203         }
24204         if (flags & NDR_IN) {
24205                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
24206                 ndr->depth++;
24207                 ndr->depth--;
24208         }
24209         if (flags & NDR_OUT) {
24210                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
24211                 ndr->depth++;
24212                 ndr_print_WERROR(ndr, "result", r->out.result);
24213                 ndr->depth--;
24214         }
24215         ndr->depth--;
24216 }
24217
24218 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
24219 {
24220         if (flags & NDR_IN) {
24221         }
24222         if (flags & NDR_OUT) {
24223                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24224         }
24225         return NDR_ERR_SUCCESS;
24226 }
24227
24228 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
24229 {
24230         if (flags & NDR_IN) {
24231         }
24232         if (flags & NDR_OUT) {
24233                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24234         }
24235         return NDR_ERR_SUCCESS;
24236 }
24237
24238 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
24239 {
24240         ndr_print_struct(ndr, name, "spoolss_DeletePort");
24241         ndr->depth++;
24242         if (flags & NDR_SET_VALUES) {
24243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24244         }
24245         if (flags & NDR_IN) {
24246                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
24247                 ndr->depth++;
24248                 ndr->depth--;
24249         }
24250         if (flags & NDR_OUT) {
24251                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
24252                 ndr->depth++;
24253                 ndr_print_WERROR(ndr, "result", r->out.result);
24254                 ndr->depth--;
24255         }
24256         ndr->depth--;
24257 }
24258
24259 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
24260 {
24261         if (flags & NDR_IN) {
24262                 if (r->in.handle == NULL) {
24263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24264                 }
24265                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24266                 if (r->in.devmode_ctr == NULL) {
24267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24268                 }
24269                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24270         }
24271         if (flags & NDR_OUT) {
24272                 if (r->out.gdi_handle == NULL) {
24273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24274                 }
24275                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24276                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24277         }
24278         return NDR_ERR_SUCCESS;
24279 }
24280
24281 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
24282 {
24283         TALLOC_CTX *_mem_save_handle_0;
24284         TALLOC_CTX *_mem_save_gdi_handle_0;
24285         TALLOC_CTX *_mem_save_devmode_ctr_0;
24286         if (flags & NDR_IN) {
24287                 ZERO_STRUCT(r->out);
24288
24289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24290                         NDR_PULL_ALLOC(ndr, r->in.handle);
24291                 }
24292                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24293                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24294                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24296                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24297                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24298                 }
24299                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24300                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24301                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24302                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24303                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24304                 ZERO_STRUCTP(r->out.gdi_handle);
24305         }
24306         if (flags & NDR_OUT) {
24307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24308                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24309                 }
24310                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24311                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24312                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24314                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24315         }
24316         return NDR_ERR_SUCCESS;
24317 }
24318
24319 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
24320 {
24321         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
24322         ndr->depth++;
24323         if (flags & NDR_SET_VALUES) {
24324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24325         }
24326         if (flags & NDR_IN) {
24327                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
24328                 ndr->depth++;
24329                 ndr_print_ptr(ndr, "handle", r->in.handle);
24330                 ndr->depth++;
24331                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24332                 ndr->depth--;
24333                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24334                 ndr->depth++;
24335                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24336                 ndr->depth--;
24337                 ndr->depth--;
24338         }
24339         if (flags & NDR_OUT) {
24340                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
24341                 ndr->depth++;
24342                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
24343                 ndr->depth++;
24344                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
24345                 ndr->depth--;
24346                 ndr_print_WERROR(ndr, "result", r->out.result);
24347                 ndr->depth--;
24348         }
24349         ndr->depth--;
24350 }
24351
24352 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24353 {
24354         if (flags & NDR_IN) {
24355         }
24356         if (flags & NDR_OUT) {
24357                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24358         }
24359         return NDR_ERR_SUCCESS;
24360 }
24361
24362 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
24363 {
24364         if (flags & NDR_IN) {
24365         }
24366         if (flags & NDR_OUT) {
24367                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24368         }
24369         return NDR_ERR_SUCCESS;
24370 }
24371
24372 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
24373 {
24374         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
24375         ndr->depth++;
24376         if (flags & NDR_SET_VALUES) {
24377                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24378         }
24379         if (flags & NDR_IN) {
24380                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
24381                 ndr->depth++;
24382                 ndr->depth--;
24383         }
24384         if (flags & NDR_OUT) {
24385                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
24386                 ndr->depth++;
24387                 ndr_print_WERROR(ndr, "result", r->out.result);
24388                 ndr->depth--;
24389         }
24390         ndr->depth--;
24391 }
24392
24393 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
24394 {
24395         if (flags & NDR_IN) {
24396                 if (r->in.gdi_handle == NULL) {
24397                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24398                 }
24399                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24400         }
24401         if (flags & NDR_OUT) {
24402                 if (r->out.gdi_handle == NULL) {
24403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24404                 }
24405                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24407         }
24408         return NDR_ERR_SUCCESS;
24409 }
24410
24411 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
24412 {
24413         TALLOC_CTX *_mem_save_gdi_handle_0;
24414         if (flags & NDR_IN) {
24415                 ZERO_STRUCT(r->out);
24416
24417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24418                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
24419                 }
24420                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24421                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24422                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
24423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24424                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24425                 *r->out.gdi_handle = *r->in.gdi_handle;
24426         }
24427         if (flags & NDR_OUT) {
24428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24429                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24430                 }
24431                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24432                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24433                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
24435                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24436         }
24437         return NDR_ERR_SUCCESS;
24438 }
24439
24440 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
24441 {
24442         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
24443         ndr->depth++;
24444         if (flags & NDR_SET_VALUES) {
24445                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24446         }
24447         if (flags & NDR_IN) {
24448                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
24449                 ndr->depth++;
24450                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
24451                 ndr->depth++;
24452                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
24453                 ndr->depth--;
24454                 ndr->depth--;
24455         }
24456         if (flags & NDR_OUT) {
24457                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
24458                 ndr->depth++;
24459                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
24460                 ndr->depth++;
24461                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
24462                 ndr->depth--;
24463                 ndr_print_WERROR(ndr, "result", r->out.result);
24464                 ndr->depth--;
24465         }
24466         ndr->depth--;
24467 }
24468
24469 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
24470 {
24471         if (flags & NDR_IN) {
24472         }
24473         if (flags & NDR_OUT) {
24474                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24475         }
24476         return NDR_ERR_SUCCESS;
24477 }
24478
24479 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
24480 {
24481         if (flags & NDR_IN) {
24482         }
24483         if (flags & NDR_OUT) {
24484                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24485         }
24486         return NDR_ERR_SUCCESS;
24487 }
24488
24489 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
24490 {
24491         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
24492         ndr->depth++;
24493         if (flags & NDR_SET_VALUES) {
24494                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24495         }
24496         if (flags & NDR_IN) {
24497                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
24498                 ndr->depth++;
24499                 ndr->depth--;
24500         }
24501         if (flags & NDR_OUT) {
24502                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
24503                 ndr->depth++;
24504                 ndr_print_WERROR(ndr, "result", r->out.result);
24505                 ndr->depth--;
24506         }
24507         ndr->depth--;
24508 }
24509
24510 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
24511 {
24512         if (flags & NDR_IN) {
24513         }
24514         if (flags & NDR_OUT) {
24515                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24516         }
24517         return NDR_ERR_SUCCESS;
24518 }
24519
24520 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
24521 {
24522         if (flags & NDR_IN) {
24523         }
24524         if (flags & NDR_OUT) {
24525                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24526         }
24527         return NDR_ERR_SUCCESS;
24528 }
24529
24530 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
24531 {
24532         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
24533         ndr->depth++;
24534         if (flags & NDR_SET_VALUES) {
24535                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24536         }
24537         if (flags & NDR_IN) {
24538                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
24539                 ndr->depth++;
24540                 ndr->depth--;
24541         }
24542         if (flags & NDR_OUT) {
24543                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
24544                 ndr->depth++;
24545                 ndr_print_WERROR(ndr, "result", r->out.result);
24546                 ndr->depth--;
24547         }
24548         ndr->depth--;
24549 }
24550
24551 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
24552 {
24553         if (flags & NDR_IN) {
24554         }
24555         if (flags & NDR_OUT) {
24556                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24557         }
24558         return NDR_ERR_SUCCESS;
24559 }
24560
24561 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
24562 {
24563         if (flags & NDR_IN) {
24564         }
24565         if (flags & NDR_OUT) {
24566                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24567         }
24568         return NDR_ERR_SUCCESS;
24569 }
24570
24571 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
24572 {
24573         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
24574         ndr->depth++;
24575         if (flags & NDR_SET_VALUES) {
24576                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24577         }
24578         if (flags & NDR_IN) {
24579                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
24580                 ndr->depth++;
24581                 ndr->depth--;
24582         }
24583         if (flags & NDR_OUT) {
24584                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
24585                 ndr->depth++;
24586                 ndr_print_WERROR(ndr, "result", r->out.result);
24587                 ndr->depth--;
24588         }
24589         ndr->depth--;
24590 }
24591
24592 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
24593 {
24594         if (flags & NDR_IN) {
24595         }
24596         if (flags & NDR_OUT) {
24597                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24598         }
24599         return NDR_ERR_SUCCESS;
24600 }
24601
24602 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
24603 {
24604         if (flags & NDR_IN) {
24605         }
24606         if (flags & NDR_OUT) {
24607                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24608         }
24609         return NDR_ERR_SUCCESS;
24610 }
24611
24612 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
24613 {
24614         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
24615         ndr->depth++;
24616         if (flags & NDR_SET_VALUES) {
24617                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24618         }
24619         if (flags & NDR_IN) {
24620                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
24621                 ndr->depth++;
24622                 ndr->depth--;
24623         }
24624         if (flags & NDR_OUT) {
24625                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
24626                 ndr->depth++;
24627                 ndr_print_WERROR(ndr, "result", r->out.result);
24628                 ndr->depth--;
24629         }
24630         ndr->depth--;
24631 }
24632
24633 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
24634 {
24635         if (flags & NDR_IN) {
24636         }
24637         if (flags & NDR_OUT) {
24638                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24639         }
24640         return NDR_ERR_SUCCESS;
24641 }
24642
24643 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
24644 {
24645         if (flags & NDR_IN) {
24646         }
24647         if (flags & NDR_OUT) {
24648                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24649         }
24650         return NDR_ERR_SUCCESS;
24651 }
24652
24653 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
24654 {
24655         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
24656         ndr->depth++;
24657         if (flags & NDR_SET_VALUES) {
24658                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24659         }
24660         if (flags & NDR_IN) {
24661                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
24662                 ndr->depth++;
24663                 ndr->depth--;
24664         }
24665         if (flags & NDR_OUT) {
24666                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
24667                 ndr->depth++;
24668                 ndr_print_WERROR(ndr, "result", r->out.result);
24669                 ndr->depth--;
24670         }
24671         ndr->depth--;
24672 }
24673
24674 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
24675 {
24676         if (flags & NDR_IN) {
24677         }
24678         if (flags & NDR_OUT) {
24679                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24680         }
24681         return NDR_ERR_SUCCESS;
24682 }
24683
24684 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
24685 {
24686         if (flags & NDR_IN) {
24687         }
24688         if (flags & NDR_OUT) {
24689                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24690         }
24691         return NDR_ERR_SUCCESS;
24692 }
24693
24694 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
24695 {
24696         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
24697         ndr->depth++;
24698         if (flags & NDR_SET_VALUES) {
24699                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24700         }
24701         if (flags & NDR_IN) {
24702                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
24703                 ndr->depth++;
24704                 ndr->depth--;
24705         }
24706         if (flags & NDR_OUT) {
24707                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
24708                 ndr->depth++;
24709                 ndr_print_WERROR(ndr, "result", r->out.result);
24710                 ndr->depth--;
24711         }
24712         ndr->depth--;
24713 }
24714
24715 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
24716 {
24717         if (flags & NDR_IN) {
24718         }
24719         if (flags & NDR_OUT) {
24720                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24721         }
24722         return NDR_ERR_SUCCESS;
24723 }
24724
24725 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
24726 {
24727         if (flags & NDR_IN) {
24728         }
24729         if (flags & NDR_OUT) {
24730                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24731         }
24732         return NDR_ERR_SUCCESS;
24733 }
24734
24735 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
24736 {
24737         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
24738         ndr->depth++;
24739         if (flags & NDR_SET_VALUES) {
24740                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24741         }
24742         if (flags & NDR_IN) {
24743                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
24744                 ndr->depth++;
24745                 ndr->depth--;
24746         }
24747         if (flags & NDR_OUT) {
24748                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
24749                 ndr->depth++;
24750                 ndr_print_WERROR(ndr, "result", r->out.result);
24751                 ndr->depth--;
24752         }
24753         ndr->depth--;
24754 }
24755
24756 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
24757 {
24758         if (flags & NDR_IN) {
24759         }
24760         if (flags & NDR_OUT) {
24761                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24762         }
24763         return NDR_ERR_SUCCESS;
24764 }
24765
24766 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
24767 {
24768         if (flags & NDR_IN) {
24769         }
24770         if (flags & NDR_OUT) {
24771                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24772         }
24773         return NDR_ERR_SUCCESS;
24774 }
24775
24776 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
24777 {
24778         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
24779         ndr->depth++;
24780         if (flags & NDR_SET_VALUES) {
24781                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24782         }
24783         if (flags & NDR_IN) {
24784                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
24785                 ndr->depth++;
24786                 ndr->depth--;
24787         }
24788         if (flags & NDR_OUT) {
24789                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
24790                 ndr->depth++;
24791                 ndr_print_WERROR(ndr, "result", r->out.result);
24792                 ndr->depth--;
24793         }
24794         ndr->depth--;
24795 }
24796
24797 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
24798 {
24799         if (flags & NDR_IN) {
24800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24801                 if (r->in.servername) {
24802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24805                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24806                 }
24807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
24808                 if (r->in.print_processor_name) {
24809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24812                         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));
24813                 }
24814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24816                 if (r->in.buffer) {
24817                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24818                 }
24819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24820         }
24821         if (flags & NDR_OUT) {
24822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24823                 if (r->out.info) {
24824                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24825                 }
24826                 if (r->out.needed == NULL) {
24827                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24828                 }
24829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24830                 if (r->out.count == NULL) {
24831                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24832                 }
24833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24834                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24835         }
24836         return NDR_ERR_SUCCESS;
24837 }
24838
24839 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
24840 {
24841         uint32_t _ptr_servername;
24842         uint32_t _ptr_print_processor_name;
24843         uint32_t _ptr_buffer;
24844         uint32_t _ptr_info;
24845         TALLOC_CTX *_mem_save_servername_0;
24846         TALLOC_CTX *_mem_save_print_processor_name_0;
24847         TALLOC_CTX *_mem_save_buffer_0;
24848         TALLOC_CTX *_mem_save_info_0;
24849         TALLOC_CTX *_mem_save_needed_0;
24850         TALLOC_CTX *_mem_save_count_0;
24851         if (flags & NDR_IN) {
24852                 ZERO_STRUCT(r->out);
24853
24854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24855                 if (_ptr_servername) {
24856                         NDR_PULL_ALLOC(ndr, r->in.servername);
24857                 } else {
24858                         r->in.servername = NULL;
24859                 }
24860                 if (r->in.servername) {
24861                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24862                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24865                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24866                                 return 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));
24867                         }
24868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24871                 }
24872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
24873                 if (_ptr_print_processor_name) {
24874                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
24875                 } else {
24876                         r->in.print_processor_name = NULL;
24877                 }
24878                 if (r->in.print_processor_name) {
24879                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24880                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
24881                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
24882                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
24883                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
24884                                 return 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));
24885                         }
24886                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
24887                         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));
24888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
24889                 }
24890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24892                 if (_ptr_buffer) {
24893                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24894                 } else {
24895                         r->in.buffer = NULL;
24896                 }
24897                 if (r->in.buffer) {
24898                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24899                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24900                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24902                 }
24903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24904                 NDR_PULL_ALLOC(ndr, r->out.needed);
24905                 ZERO_STRUCTP(r->out.needed);
24906                 NDR_PULL_ALLOC(ndr, r->out.count);
24907                 ZERO_STRUCTP(r->out.count);
24908         }
24909         if (flags & NDR_OUT) {
24910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24911                 if (_ptr_info) {
24912                         NDR_PULL_ALLOC(ndr, r->out.info);
24913                 } else {
24914                         r->out.info = NULL;
24915                 }
24916                 if (r->out.info) {
24917                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24918                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24919                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24921                 }
24922                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24923                         NDR_PULL_ALLOC(ndr, r->out.needed);
24924                 }
24925                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24926                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24928                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24929                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24930                         NDR_PULL_ALLOC(ndr, r->out.count);
24931                 }
24932                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24933                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24935                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24936                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24937         }
24938         return NDR_ERR_SUCCESS;
24939 }
24940
24941 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
24942 {
24943         uint32_t cntr_info_0;
24944         if (flags & NDR_IN) {
24945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24947         }
24948         if (flags & NDR_OUT) {
24949                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24950                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24951                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24952                 }
24953                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24954                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24955                 }
24956         }
24957         return NDR_ERR_SUCCESS;
24958 }
24959
24960 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
24961 {
24962         uint32_t cntr_info_0;
24963         TALLOC_CTX *_mem_save_info_0;
24964         if (flags & NDR_IN) {
24965                 ZERO_STRUCT(r->out);
24966
24967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24969         }
24970         if (flags & NDR_OUT) {
24971                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24972                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24973                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24974                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24975                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24976                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24977                 }
24978                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24979                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24980                 }
24981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24982         }
24983         return NDR_ERR_SUCCESS;
24984 }
24985
24986 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
24987 {
24988         uint32_t cntr_info_2;
24989         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
24990         ndr->depth++;
24991         if (flags & NDR_SET_VALUES) {
24992                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24993         }
24994         if (flags & NDR_IN) {
24995                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
24996                 ndr->depth++;
24997                 ndr_print_ptr(ndr, "servername", r->in.servername);
24998                 ndr->depth++;
24999                 if (r->in.servername) {
25000                         ndr_print_string(ndr, "servername", r->in.servername);
25001                 }
25002                 ndr->depth--;
25003                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
25004                 ndr->depth++;
25005                 if (r->in.print_processor_name) {
25006                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
25007                 }
25008                 ndr->depth--;
25009                 ndr_print_uint32(ndr, "level", r->in.level);
25010                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25011                 ndr->depth++;
25012                 if (r->in.buffer) {
25013                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25014                 }
25015                 ndr->depth--;
25016                 ndr_print_uint32(ndr, "offered", r->in.offered);
25017                 ndr->depth--;
25018         }
25019         if (flags & NDR_OUT) {
25020                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
25021                 ndr->depth++;
25022                 ndr_print_ptr(ndr, "count", r->out.count);
25023                 ndr->depth++;
25024                 ndr_print_uint32(ndr, "count", *r->out.count);
25025                 ndr->depth--;
25026                 ndr_print_ptr(ndr, "info", r->out.info);
25027                 ndr->depth++;
25028                 ndr_print_ptr(ndr, "info", *r->out.info);
25029                 ndr->depth++;
25030                 if (*r->out.info) {
25031                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25032                         ndr->depth++;
25033                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25034                                 char *idx_2=NULL;
25035                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25036                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25037                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25038                                         free(idx_2);
25039                                 }
25040                         }
25041                         ndr->depth--;
25042                 }
25043                 ndr->depth--;
25044                 ndr->depth--;
25045                 ndr_print_ptr(ndr, "needed", r->out.needed);
25046                 ndr->depth++;
25047                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25048                 ndr->depth--;
25049                 ndr_print_WERROR(ndr, "result", r->out.result);
25050                 ndr->depth--;
25051         }
25052         ndr->depth--;
25053 }
25054
25055 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
25056 {
25057         if (flags & NDR_IN) {
25058                 if (r->in.handle == NULL) {
25059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25060                 }
25061                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
25063                 if (r->in.data_type) {
25064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25067                         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));
25068                 }
25069                 if (r->in.devmode_ctr == NULL) {
25070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25071                 }
25072                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25073         }
25074         if (flags & NDR_OUT) {
25075                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25076         }
25077         return NDR_ERR_SUCCESS;
25078 }
25079
25080 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25081 {
25082         uint32_t _ptr_data_type;
25083         TALLOC_CTX *_mem_save_handle_0;
25084         TALLOC_CTX *_mem_save_data_type_0;
25085         TALLOC_CTX *_mem_save_devmode_ctr_0;
25086         if (flags & NDR_IN) {
25087                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25088                         NDR_PULL_ALLOC(ndr, r->in.handle);
25089                 }
25090                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25092                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25093                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25095                 if (_ptr_data_type) {
25096                         NDR_PULL_ALLOC(ndr, r->in.data_type);
25097                 } else {
25098                         r->in.data_type = NULL;
25099                 }
25100                 if (r->in.data_type) {
25101                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25102                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25105                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
25106                                 return 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));
25107                         }
25108                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
25109                         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));
25110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
25111                 }
25112                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25113                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25114                 }
25115                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25116                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25117                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25118                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25119         }
25120         if (flags & NDR_OUT) {
25121                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25122         }
25123         return NDR_ERR_SUCCESS;
25124 }
25125
25126 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
25127 {
25128         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
25129         ndr->depth++;
25130         if (flags & NDR_SET_VALUES) {
25131                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25132         }
25133         if (flags & NDR_IN) {
25134                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
25135                 ndr->depth++;
25136                 ndr_print_ptr(ndr, "handle", r->in.handle);
25137                 ndr->depth++;
25138                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25139                 ndr->depth--;
25140                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
25141                 ndr->depth++;
25142                 if (r->in.data_type) {
25143                         ndr_print_string(ndr, "data_type", r->in.data_type);
25144                 }
25145                 ndr->depth--;
25146                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25147                 ndr->depth++;
25148                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25149                 ndr->depth--;
25150                 ndr->depth--;
25151         }
25152         if (flags & NDR_OUT) {
25153                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
25154                 ndr->depth++;
25155                 ndr_print_WERROR(ndr, "result", r->out.result);
25156                 ndr->depth--;
25157         }
25158         ndr->depth--;
25159 }
25160
25161 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
25162 {
25163         if (flags & NDR_IN) {
25164                 if (r->in.handle == NULL) {
25165                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25166                 }
25167                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
25169                 if (r->in.architecture) {
25170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25172                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25173                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25174                 }
25175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25176                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25177                 if (r->in.buffer) {
25178                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25179                 }
25180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
25182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
25183         }
25184         if (flags & NDR_OUT) {
25185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25186                 if (r->out.info) {
25187                         {
25188                                 struct ndr_push *_ndr_info;
25189                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25190                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
25191                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25192                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25193                         }
25194                 }
25195                 if (r->out.needed == NULL) {
25196                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25197                 }
25198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25199                 if (r->out.server_major_version == NULL) {
25200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25201                 }
25202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
25203                 if (r->out.server_minor_version == NULL) {
25204                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25205                 }
25206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
25207                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25208         }
25209         return NDR_ERR_SUCCESS;
25210 }
25211
25212 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
25213 {
25214         uint32_t _ptr_architecture;
25215         uint32_t _ptr_buffer;
25216         uint32_t _ptr_info;
25217         TALLOC_CTX *_mem_save_handle_0;
25218         TALLOC_CTX *_mem_save_architecture_0;
25219         TALLOC_CTX *_mem_save_buffer_0;
25220         TALLOC_CTX *_mem_save_info_0;
25221         TALLOC_CTX *_mem_save_needed_0;
25222         TALLOC_CTX *_mem_save_server_major_version_0;
25223         TALLOC_CTX *_mem_save_server_minor_version_0;
25224         if (flags & NDR_IN) {
25225                 ZERO_STRUCT(r->out);
25226
25227                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25228                         NDR_PULL_ALLOC(ndr, r->in.handle);
25229                 }
25230                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25231                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25232                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25233                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25234                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
25235                 if (_ptr_architecture) {
25236                         NDR_PULL_ALLOC(ndr, r->in.architecture);
25237                 } else {
25238                         r->in.architecture = NULL;
25239                 }
25240                 if (r->in.architecture) {
25241                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
25242                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
25243                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
25244                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
25245                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
25246                                 return 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));
25247                         }
25248                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
25249                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
25250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
25251                 }
25252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25253                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25254                 if (_ptr_buffer) {
25255                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25256                 } else {
25257                         r->in.buffer = NULL;
25258                 }
25259                 if (r->in.buffer) {
25260                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25261                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25262                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25264                 }
25265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
25267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
25268                 NDR_PULL_ALLOC(ndr, r->out.needed);
25269                 ZERO_STRUCTP(r->out.needed);
25270                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25271                 ZERO_STRUCTP(r->out.server_major_version);
25272                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25273                 ZERO_STRUCTP(r->out.server_minor_version);
25274         }
25275         if (flags & NDR_OUT) {
25276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25277                 if (_ptr_info) {
25278                         NDR_PULL_ALLOC(ndr, r->out.info);
25279                 } else {
25280                         r->out.info = NULL;
25281                 }
25282                 if (r->out.info) {
25283                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25284                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25285                         {
25286                                 struct ndr_pull *_ndr_info;
25287                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25288                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
25289                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25290                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25291                         }
25292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25293                 }
25294                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25295                         NDR_PULL_ALLOC(ndr, r->out.needed);
25296                 }
25297                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25298                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25301                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25302                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25303                 }
25304                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25305                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
25306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
25307                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
25308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25309                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25310                 }
25311                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
25313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
25314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
25315                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25316         }
25317         return NDR_ERR_SUCCESS;
25318 }
25319
25320 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
25321 {
25322         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
25323         ndr->depth++;
25324         if (flags & NDR_SET_VALUES) {
25325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25326         }
25327         if (flags & NDR_IN) {
25328                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
25329                 ndr->depth++;
25330                 ndr_print_ptr(ndr, "handle", r->in.handle);
25331                 ndr->depth++;
25332                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25333                 ndr->depth--;
25334                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
25335                 ndr->depth++;
25336                 if (r->in.architecture) {
25337                         ndr_print_string(ndr, "architecture", r->in.architecture);
25338                 }
25339                 ndr->depth--;
25340                 ndr_print_uint32(ndr, "level", r->in.level);
25341                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25342                 ndr->depth++;
25343                 if (r->in.buffer) {
25344                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25345                 }
25346                 ndr->depth--;
25347                 ndr_print_uint32(ndr, "offered", r->in.offered);
25348                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
25349                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
25350                 ndr->depth--;
25351         }
25352         if (flags & NDR_OUT) {
25353                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
25354                 ndr->depth++;
25355                 ndr_print_ptr(ndr, "info", r->out.info);
25356                 ndr->depth++;
25357                 if (r->out.info) {
25358                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
25359                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
25360                 }
25361                 ndr->depth--;
25362                 ndr_print_ptr(ndr, "needed", r->out.needed);
25363                 ndr->depth++;
25364                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25365                 ndr->depth--;
25366                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
25367                 ndr->depth++;
25368                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
25369                 ndr->depth--;
25370                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
25371                 ndr->depth++;
25372                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
25373                 ndr->depth--;
25374                 ndr_print_WERROR(ndr, "result", r->out.result);
25375                 ndr->depth--;
25376         }
25377         ndr->depth--;
25378 }
25379
25380 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25381 {
25382         if (flags & NDR_IN) {
25383         }
25384         if (flags & NDR_OUT) {
25385                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25386         }
25387         return NDR_ERR_SUCCESS;
25388 }
25389
25390 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
25391 {
25392         if (flags & NDR_IN) {
25393         }
25394         if (flags & NDR_OUT) {
25395                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25396         }
25397         return NDR_ERR_SUCCESS;
25398 }
25399
25400 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
25401 {
25402         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
25403         ndr->depth++;
25404         if (flags & NDR_SET_VALUES) {
25405                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25406         }
25407         if (flags & NDR_IN) {
25408                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
25409                 ndr->depth++;
25410                 ndr->depth--;
25411         }
25412         if (flags & NDR_OUT) {
25413                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
25414                 ndr->depth++;
25415                 ndr_print_WERROR(ndr, "result", r->out.result);
25416                 ndr->depth--;
25417         }
25418         ndr->depth--;
25419 }
25420
25421 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25422 {
25423         if (flags & NDR_IN) {
25424         }
25425         if (flags & NDR_OUT) {
25426                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25427         }
25428         return NDR_ERR_SUCCESS;
25429 }
25430
25431 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
25432 {
25433         if (flags & NDR_IN) {
25434         }
25435         if (flags & NDR_OUT) {
25436                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25437         }
25438         return NDR_ERR_SUCCESS;
25439 }
25440
25441 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
25442 {
25443         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
25444         ndr->depth++;
25445         if (flags & NDR_SET_VALUES) {
25446                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25447         }
25448         if (flags & NDR_IN) {
25449                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
25450                 ndr->depth++;
25451                 ndr->depth--;
25452         }
25453         if (flags & NDR_OUT) {
25454                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
25455                 ndr->depth++;
25456                 ndr_print_WERROR(ndr, "result", r->out.result);
25457                 ndr->depth--;
25458         }
25459         ndr->depth--;
25460 }
25461
25462 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
25463 {
25464         if (flags & NDR_IN) {
25465                 if (r->in.handle == NULL) {
25466                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25467                 }
25468                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25469         }
25470         if (flags & NDR_OUT) {
25471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25472         }
25473         return NDR_ERR_SUCCESS;
25474 }
25475
25476 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
25477 {
25478         TALLOC_CTX *_mem_save_handle_0;
25479         if (flags & NDR_IN) {
25480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25481                         NDR_PULL_ALLOC(ndr, r->in.handle);
25482                 }
25483                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25484                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25485                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25487         }
25488         if (flags & NDR_OUT) {
25489                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25490         }
25491         return NDR_ERR_SUCCESS;
25492 }
25493
25494 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
25495 {
25496         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
25497         ndr->depth++;
25498         if (flags & NDR_SET_VALUES) {
25499                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25500         }
25501         if (flags & NDR_IN) {
25502                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
25503                 ndr->depth++;
25504                 ndr_print_ptr(ndr, "handle", r->in.handle);
25505                 ndr->depth++;
25506                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25507                 ndr->depth--;
25508                 ndr->depth--;
25509         }
25510         if (flags & NDR_OUT) {
25511                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
25512                 ndr->depth++;
25513                 ndr_print_WERROR(ndr, "result", r->out.result);
25514                 ndr->depth--;
25515         }
25516         ndr->depth--;
25517 }
25518
25519 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25520 {
25521         if (flags & NDR_IN) {
25522         }
25523         if (flags & NDR_OUT) {
25524                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25525         }
25526         return NDR_ERR_SUCCESS;
25527 }
25528
25529 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25530 {
25531         if (flags & NDR_IN) {
25532         }
25533         if (flags & NDR_OUT) {
25534                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25535         }
25536         return NDR_ERR_SUCCESS;
25537 }
25538
25539 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
25540 {
25541         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25542         ndr->depth++;
25543         if (flags & NDR_SET_VALUES) {
25544                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25545         }
25546         if (flags & NDR_IN) {
25547                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25548                 ndr->depth++;
25549                 ndr->depth--;
25550         }
25551         if (flags & NDR_OUT) {
25552                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
25553                 ndr->depth++;
25554                 ndr_print_WERROR(ndr, "result", r->out.result);
25555                 ndr->depth--;
25556         }
25557         ndr->depth--;
25558 }
25559
25560 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
25561 {
25562         if (flags & NDR_IN) {
25563                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25564                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25565                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25566                 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));
25567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25568                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
25569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25570                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25571                 if (r->in.buffer) {
25572                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
25573                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
25574                 }
25575         }
25576         if (flags & NDR_OUT) {
25577                 if (r->out.handle == NULL) {
25578                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25579                 }
25580                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25581                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25582         }
25583         return NDR_ERR_SUCCESS;
25584 }
25585
25586 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
25587 {
25588         uint32_t _ptr_buffer;
25589         TALLOC_CTX *_mem_save_buffer_0;
25590         TALLOC_CTX *_mem_save_handle_0;
25591         if (flags & NDR_IN) {
25592                 ZERO_STRUCT(r->out);
25593
25594                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25595                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25596                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25597                         return 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));
25598                 }
25599                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25600                 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));
25601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25602                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
25603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
25604                 if (r->in.bufsize > 512) {
25605                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
25606                 }
25607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25608                 if (_ptr_buffer) {
25609                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25610                 } else {
25611                         r->in.buffer = NULL;
25612                 }
25613                 if (r->in.buffer) {
25614                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25615                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25616                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25617                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25618                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25620                 }
25621                 NDR_PULL_ALLOC(ndr, r->out.handle);
25622                 ZERO_STRUCTP(r->out.handle);
25623                 if (r->in.buffer) {
25624                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
25625                 }
25626         }
25627         if (flags & NDR_OUT) {
25628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25629                         NDR_PULL_ALLOC(ndr, r->out.handle);
25630                 }
25631                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25632                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25633                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25635                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25636         }
25637         return NDR_ERR_SUCCESS;
25638 }
25639
25640 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
25641 {
25642         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
25643         ndr->depth++;
25644         if (flags & NDR_SET_VALUES) {
25645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25646         }
25647         if (flags & NDR_IN) {
25648                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
25649                 ndr->depth++;
25650                 ndr_print_string(ndr, "server_name", r->in.server_name);
25651                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25652                 ndr_print_winreg_Type(ndr, "type", r->in.type);
25653                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
25654                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25655                 ndr->depth++;
25656                 if (r->in.buffer) {
25657                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
25658                 }
25659                 ndr->depth--;
25660                 ndr->depth--;
25661         }
25662         if (flags & NDR_OUT) {
25663                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
25664                 ndr->depth++;
25665                 ndr_print_ptr(ndr, "handle", r->out.handle);
25666                 ndr->depth++;
25667                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25668                 ndr->depth--;
25669                 ndr_print_WERROR(ndr, "result", r->out.result);
25670                 ndr->depth--;
25671         }
25672         ndr->depth--;
25673 }
25674
25675 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
25676 {
25677         if (flags & NDR_IN) {
25678                 if (r->in.handle == NULL) {
25679                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25680                 }
25681                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25682                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
25684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25685                 if (r->in.buffer) {
25686                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
25687                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
25688                 }
25689         }
25690         if (flags & NDR_OUT) {
25691                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25692         }
25693         return NDR_ERR_SUCCESS;
25694 }
25695
25696 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
25697 {
25698         uint32_t _ptr_buffer;
25699         TALLOC_CTX *_mem_save_handle_0;
25700         TALLOC_CTX *_mem_save_buffer_0;
25701         if (flags & NDR_IN) {
25702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25703                         NDR_PULL_ALLOC(ndr, r->in.handle);
25704                 }
25705                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25706                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25707                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25709                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
25711                 if (r->in.bufsize > 512) {
25712                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
25713                 }
25714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25715                 if (_ptr_buffer) {
25716                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25717                 } else {
25718                         r->in.buffer = NULL;
25719                 }
25720                 if (r->in.buffer) {
25721                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25722                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25723                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25724                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25725                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25727                 }
25728                 if (r->in.buffer) {
25729                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
25730                 }
25731         }
25732         if (flags & NDR_OUT) {
25733                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25734         }
25735         return NDR_ERR_SUCCESS;
25736 }
25737
25738 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
25739 {
25740         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
25741         ndr->depth++;
25742         if (flags & NDR_SET_VALUES) {
25743                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25744         }
25745         if (flags & NDR_IN) {
25746                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
25747                 ndr->depth++;
25748                 ndr_print_ptr(ndr, "handle", r->in.handle);
25749                 ndr->depth++;
25750                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25751                 ndr->depth--;
25752                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25753                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
25754                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25755                 ndr->depth++;
25756                 if (r->in.buffer) {
25757                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
25758                 }
25759                 ndr->depth--;
25760                 ndr->depth--;
25761         }
25762         if (flags & NDR_OUT) {
25763                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
25764                 ndr->depth++;
25765                 ndr_print_WERROR(ndr, "result", r->out.result);
25766                 ndr->depth--;
25767         }
25768         ndr->depth--;
25769 }
25770
25771 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
25772 {
25773         if (flags & NDR_IN) {
25774                 if (r->in.handle == NULL) {
25775                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25776                 }
25777                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25778         }
25779         if (flags & NDR_OUT) {
25780                 if (r->out.handle == NULL) {
25781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25782                 }
25783                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25784                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25785         }
25786         return NDR_ERR_SUCCESS;
25787 }
25788
25789 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
25790 {
25791         TALLOC_CTX *_mem_save_handle_0;
25792         if (flags & NDR_IN) {
25793                 ZERO_STRUCT(r->out);
25794
25795                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25796                         NDR_PULL_ALLOC(ndr, r->in.handle);
25797                 }
25798                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25799                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25800                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25801                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25802                 NDR_PULL_ALLOC(ndr, r->out.handle);
25803                 *r->out.handle = *r->in.handle;
25804         }
25805         if (flags & NDR_OUT) {
25806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25807                         NDR_PULL_ALLOC(ndr, r->out.handle);
25808                 }
25809                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25810                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25811                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25813                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25814         }
25815         return NDR_ERR_SUCCESS;
25816 }
25817
25818 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
25819 {
25820         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
25821         ndr->depth++;
25822         if (flags & NDR_SET_VALUES) {
25823                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25824         }
25825         if (flags & NDR_IN) {
25826                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
25827                 ndr->depth++;
25828                 ndr_print_ptr(ndr, "handle", r->in.handle);
25829                 ndr->depth++;
25830                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25831                 ndr->depth--;
25832                 ndr->depth--;
25833         }
25834         if (flags & NDR_OUT) {
25835                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
25836                 ndr->depth++;
25837                 ndr_print_ptr(ndr, "handle", r->out.handle);
25838                 ndr->depth++;
25839                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25840                 ndr->depth--;
25841                 ndr_print_WERROR(ndr, "result", r->out.result);
25842                 ndr->depth--;
25843         }
25844         ndr->depth--;
25845 }
25846
25847 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
25848 {
25849         if (flags & NDR_IN) {
25850         }
25851         if (flags & NDR_OUT) {
25852                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25853         }
25854         return NDR_ERR_SUCCESS;
25855 }
25856
25857 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
25858 {
25859         if (flags & NDR_IN) {
25860         }
25861         if (flags & NDR_OUT) {
25862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25863         }
25864         return NDR_ERR_SUCCESS;
25865 }
25866
25867 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
25868 {
25869         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
25870         ndr->depth++;
25871         if (flags & NDR_SET_VALUES) {
25872                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25873         }
25874         if (flags & NDR_IN) {
25875                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
25876                 ndr->depth++;
25877                 ndr->depth--;
25878         }
25879         if (flags & NDR_OUT) {
25880                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
25881                 ndr->depth++;
25882                 ndr_print_WERROR(ndr, "result", r->out.result);
25883                 ndr->depth--;
25884         }
25885         ndr->depth--;
25886 }
25887
25888 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25889 {
25890         if (flags & NDR_IN) {
25891         }
25892         if (flags & NDR_OUT) {
25893                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25894         }
25895         return NDR_ERR_SUCCESS;
25896 }
25897
25898 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25899 {
25900         if (flags & NDR_IN) {
25901         }
25902         if (flags & NDR_OUT) {
25903                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25904         }
25905         return NDR_ERR_SUCCESS;
25906 }
25907
25908 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25909 {
25910         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
25911         ndr->depth++;
25912         if (flags & NDR_SET_VALUES) {
25913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25914         }
25915         if (flags & NDR_IN) {
25916                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
25917                 ndr->depth++;
25918                 ndr->depth--;
25919         }
25920         if (flags & NDR_OUT) {
25921                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
25922                 ndr->depth++;
25923                 ndr_print_WERROR(ndr, "result", r->out.result);
25924                 ndr->depth--;
25925         }
25926         ndr->depth--;
25927 }
25928
25929 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
25930 {
25931         if (flags & NDR_IN) {
25932         }
25933         if (flags & NDR_OUT) {
25934                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25935         }
25936         return NDR_ERR_SUCCESS;
25937 }
25938
25939 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
25940 {
25941         if (flags & NDR_IN) {
25942         }
25943         if (flags & NDR_OUT) {
25944                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25945         }
25946         return NDR_ERR_SUCCESS;
25947 }
25948
25949 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
25950 {
25951         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
25952         ndr->depth++;
25953         if (flags & NDR_SET_VALUES) {
25954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25955         }
25956         if (flags & NDR_IN) {
25957                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
25958                 ndr->depth++;
25959                 ndr->depth--;
25960         }
25961         if (flags & NDR_OUT) {
25962                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
25963                 ndr->depth++;
25964                 ndr_print_WERROR(ndr, "result", r->out.result);
25965                 ndr->depth--;
25966         }
25967         ndr->depth--;
25968 }
25969
25970 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
25971 {
25972         if (flags & NDR_IN) {
25973         }
25974         if (flags & NDR_OUT) {
25975                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25976         }
25977         return NDR_ERR_SUCCESS;
25978 }
25979
25980 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
25981 {
25982         if (flags & NDR_IN) {
25983         }
25984         if (flags & NDR_OUT) {
25985                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25986         }
25987         return NDR_ERR_SUCCESS;
25988 }
25989
25990 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
25991 {
25992         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
25993         ndr->depth++;
25994         if (flags & NDR_SET_VALUES) {
25995                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25996         }
25997         if (flags & NDR_IN) {
25998                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
25999                 ndr->depth++;
26000                 ndr->depth--;
26001         }
26002         if (flags & NDR_OUT) {
26003                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
26004                 ndr->depth++;
26005                 ndr_print_WERROR(ndr, "result", r->out.result);
26006                 ndr->depth--;
26007         }
26008         ndr->depth--;
26009 }
26010
26011 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26012 {
26013         if (flags & NDR_IN) {
26014                 if (r->in.handle == NULL) {
26015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26016                 }
26017                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26018                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
26020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
26021                 if (r->in.local_machine) {
26022                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26023                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26024                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26025                         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));
26026                 }
26027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
26029                 if (r->in.notify_options) {
26030                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26031                 }
26032         }
26033         if (flags & NDR_OUT) {
26034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26035         }
26036         return NDR_ERR_SUCCESS;
26037 }
26038
26039 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26040 {
26041         uint32_t _ptr_local_machine;
26042         uint32_t _ptr_notify_options;
26043         TALLOC_CTX *_mem_save_handle_0;
26044         TALLOC_CTX *_mem_save_local_machine_0;
26045         TALLOC_CTX *_mem_save_notify_options_0;
26046         if (flags & NDR_IN) {
26047                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26048                         NDR_PULL_ALLOC(ndr, r->in.handle);
26049                 }
26050                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26051                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26052                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26053                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26054                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
26056                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
26057                 if (_ptr_local_machine) {
26058                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
26059                 } else {
26060                         r->in.local_machine = NULL;
26061                 }
26062                 if (r->in.local_machine) {
26063                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
26064                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
26065                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
26066                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
26067                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
26068                                 return 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));
26069                         }
26070                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
26071                         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));
26072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
26073                 }
26074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
26076                 if (_ptr_notify_options) {
26077                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
26078                 } else {
26079                         r->in.notify_options = NULL;
26080                 }
26081                 if (r->in.notify_options) {
26082                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26083                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26084                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26085                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26086                 }
26087         }
26088         if (flags & NDR_OUT) {
26089                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26090         }
26091         return NDR_ERR_SUCCESS;
26092 }
26093
26094 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26095 {
26096         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26097         ndr->depth++;
26098         if (flags & NDR_SET_VALUES) {
26099                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26100         }
26101         if (flags & NDR_IN) {
26102                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26103                 ndr->depth++;
26104                 ndr_print_ptr(ndr, "handle", r->in.handle);
26105                 ndr->depth++;
26106                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26107                 ndr->depth--;
26108                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26109                 ndr_print_uint32(ndr, "options", r->in.options);
26110                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
26111                 ndr->depth++;
26112                 if (r->in.local_machine) {
26113                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
26114                 }
26115                 ndr->depth--;
26116                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26117                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
26118                 ndr->depth++;
26119                 if (r->in.notify_options) {
26120                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
26121                 }
26122                 ndr->depth--;
26123                 ndr->depth--;
26124         }
26125         if (flags & NDR_OUT) {
26126                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26127                 ndr->depth++;
26128                 ndr_print_WERROR(ndr, "result", r->out.result);
26129                 ndr->depth--;
26130         }
26131         ndr->depth--;
26132 }
26133
26134 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26135 {
26136         if (flags & NDR_IN) {
26137                 if (r->in.handle == NULL) {
26138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26139                 }
26140                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
26142                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
26144                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26145                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26146         }
26147         if (flags & NDR_OUT) {
26148                 if (r->out.reply_result == NULL) {
26149                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26150                 }
26151                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
26152                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26153         }
26154         return NDR_ERR_SUCCESS;
26155 }
26156
26157 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
26158 {
26159         TALLOC_CTX *_mem_save_handle_0;
26160         TALLOC_CTX *_mem_save_reply_result_0;
26161         if (flags & NDR_IN) {
26162                 ZERO_STRUCT(r->out);
26163
26164                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26165                         NDR_PULL_ALLOC(ndr, r->in.handle);
26166                 }
26167                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26168                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26169                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26170                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
26172                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
26174                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26175                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26176                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
26177                 ZERO_STRUCTP(r->out.reply_result);
26178         }
26179         if (flags & NDR_OUT) {
26180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26181                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
26182                 }
26183                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
26184                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
26185                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
26186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
26187                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26188         }
26189         return NDR_ERR_SUCCESS;
26190 }
26191
26192 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26193 {
26194         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
26195         ndr->depth++;
26196         if (flags & NDR_SET_VALUES) {
26197                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26198         }
26199         if (flags & NDR_IN) {
26200                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
26201                 ndr->depth++;
26202                 ndr_print_ptr(ndr, "handle", r->in.handle);
26203                 ndr->depth++;
26204                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26205                 ndr->depth--;
26206                 ndr_print_uint32(ndr, "color", r->in.color);
26207                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26208                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
26209                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
26210                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
26211                 ndr->depth--;
26212         }
26213         if (flags & NDR_OUT) {
26214                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
26215                 ndr->depth++;
26216                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
26217                 ndr->depth++;
26218                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
26219                 ndr->depth--;
26220                 ndr_print_WERROR(ndr, "result", r->out.result);
26221                 ndr->depth--;
26222         }
26223         ndr->depth--;
26224 }
26225
26226 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26227 {
26228         if (flags & NDR_IN) {
26229                 if (r->in.handle == NULL) {
26230                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26231                 }
26232                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
26234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
26235                 if (r->in.options) {
26236                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26237                 }
26238         }
26239         if (flags & NDR_OUT) {
26240                 if (r->out.info == NULL) {
26241                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26242                 }
26243                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
26244                 if (*r->out.info) {
26245                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26246                 }
26247                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26248         }
26249         return NDR_ERR_SUCCESS;
26250 }
26251
26252 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
26253 {
26254         uint32_t _ptr_options;
26255         uint32_t _ptr_info;
26256         TALLOC_CTX *_mem_save_handle_0;
26257         TALLOC_CTX *_mem_save_options_0;
26258         TALLOC_CTX *_mem_save_info_0;
26259         TALLOC_CTX *_mem_save_info_1;
26260         if (flags & NDR_IN) {
26261                 ZERO_STRUCT(r->out);
26262
26263                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26264                         NDR_PULL_ALLOC(ndr, r->in.handle);
26265                 }
26266                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26267                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26268                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26269                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
26271                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
26272                 if (_ptr_options) {
26273                         NDR_PULL_ALLOC(ndr, r->in.options);
26274                 } else {
26275                         r->in.options = NULL;
26276                 }
26277                 if (r->in.options) {
26278                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26279                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
26280                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
26282                 }
26283                 NDR_PULL_ALLOC(ndr, r->out.info);
26284                 ZERO_STRUCTP(r->out.info);
26285         }
26286         if (flags & NDR_OUT) {
26287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26288                         NDR_PULL_ALLOC(ndr, r->out.info);
26289                 }
26290                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26291                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
26292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26293                 if (_ptr_info) {
26294                         NDR_PULL_ALLOC(ndr, *r->out.info);
26295                 } else {
26296                         *r->out.info = NULL;
26297                 }
26298                 if (*r->out.info) {
26299                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
26300                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
26301                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
26303                 }
26304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
26305                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26306         }
26307         return NDR_ERR_SUCCESS;
26308 }
26309
26310 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26311 {
26312         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
26313         ndr->depth++;
26314         if (flags & NDR_SET_VALUES) {
26315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26316         }
26317         if (flags & NDR_IN) {
26318                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
26319                 ndr->depth++;
26320                 ndr_print_ptr(ndr, "handle", r->in.handle);
26321                 ndr->depth++;
26322                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26323                 ndr->depth--;
26324                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
26325                 ndr_print_ptr(ndr, "options", r->in.options);
26326                 ndr->depth++;
26327                 if (r->in.options) {
26328                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
26329                 }
26330                 ndr->depth--;
26331                 ndr->depth--;
26332         }
26333         if (flags & NDR_OUT) {
26334                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
26335                 ndr->depth++;
26336                 ndr_print_ptr(ndr, "info", r->out.info);
26337                 ndr->depth++;
26338                 ndr_print_ptr(ndr, "info", *r->out.info);
26339                 ndr->depth++;
26340                 if (*r->out.info) {
26341                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
26342                 }
26343                 ndr->depth--;
26344                 ndr->depth--;
26345                 ndr_print_WERROR(ndr, "result", r->out.result);
26346                 ndr->depth--;
26347         }
26348         ndr->depth--;
26349 }
26350
26351 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
26352 {
26353         if (flags & NDR_IN) {
26354         }
26355         if (flags & NDR_OUT) {
26356                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26357         }
26358         return NDR_ERR_SUCCESS;
26359 }
26360
26361 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
26362 {
26363         if (flags & NDR_IN) {
26364         }
26365         if (flags & NDR_OUT) {
26366                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26367         }
26368         return NDR_ERR_SUCCESS;
26369 }
26370
26371 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
26372 {
26373         ndr_print_struct(ndr, name, "spoolss_44");
26374         ndr->depth++;
26375         if (flags & NDR_SET_VALUES) {
26376                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26377         }
26378         if (flags & NDR_IN) {
26379                 ndr_print_struct(ndr, "in", "spoolss_44");
26380                 ndr->depth++;
26381                 ndr->depth--;
26382         }
26383         if (flags & NDR_OUT) {
26384                 ndr_print_struct(ndr, "out", "spoolss_44");
26385                 ndr->depth++;
26386                 ndr_print_WERROR(ndr, "result", r->out.result);
26387                 ndr->depth--;
26388         }
26389         ndr->depth--;
26390 }
26391
26392 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
26393 {
26394         if (flags & NDR_IN) {
26395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
26396                 if (r->in.printername) {
26397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
26400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26401                 }
26402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
26403                 if (r->in.datatype) {
26404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26406                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
26407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26408                 }
26409                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26410                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
26411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26412                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26413                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26414         }
26415         if (flags & NDR_OUT) {
26416                 if (r->out.handle == NULL) {
26417                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26418                 }
26419                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26420                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26421         }
26422         return NDR_ERR_SUCCESS;
26423 }
26424
26425 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
26426 {
26427         uint32_t _ptr_printername;
26428         uint32_t _ptr_datatype;
26429         TALLOC_CTX *_mem_save_printername_0;
26430         TALLOC_CTX *_mem_save_datatype_0;
26431         TALLOC_CTX *_mem_save_handle_0;
26432         if (flags & NDR_IN) {
26433                 ZERO_STRUCT(r->out);
26434
26435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
26436                 if (_ptr_printername) {
26437                         NDR_PULL_ALLOC(ndr, r->in.printername);
26438                 } else {
26439                         r->in.printername = NULL;
26440                 }
26441                 if (r->in.printername) {
26442                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26443                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
26444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
26445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
26446                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
26447                                 return 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));
26448                         }
26449                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
26450                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
26451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
26452                 }
26453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
26454                 if (_ptr_datatype) {
26455                         NDR_PULL_ALLOC(ndr, r->in.datatype);
26456                 } else {
26457                         r->in.datatype = NULL;
26458                 }
26459                 if (r->in.datatype) {
26460                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
26461                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
26462                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
26463                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
26464                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
26465                                 return 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));
26466                         }
26467                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
26468                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
26469                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
26470                 }
26471                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
26472                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
26473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26474                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
26475                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
26476                 NDR_PULL_ALLOC(ndr, r->out.handle);
26477                 ZERO_STRUCTP(r->out.handle);
26478         }
26479         if (flags & NDR_OUT) {
26480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26481                         NDR_PULL_ALLOC(ndr, r->out.handle);
26482                 }
26483                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26484                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26485                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26487                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26488         }
26489         return NDR_ERR_SUCCESS;
26490 }
26491
26492 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
26493 {
26494         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
26495         ndr->depth++;
26496         if (flags & NDR_SET_VALUES) {
26497                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26498         }
26499         if (flags & NDR_IN) {
26500                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
26501                 ndr->depth++;
26502                 ndr_print_ptr(ndr, "printername", r->in.printername);
26503                 ndr->depth++;
26504                 if (r->in.printername) {
26505                         ndr_print_string(ndr, "printername", r->in.printername);
26506                 }
26507                 ndr->depth--;
26508                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
26509                 ndr->depth++;
26510                 if (r->in.datatype) {
26511                         ndr_print_string(ndr, "datatype", r->in.datatype);
26512                 }
26513                 ndr->depth--;
26514                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
26515                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
26516                 ndr_print_uint32(ndr, "level", r->in.level);
26517                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
26518                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
26519                 ndr->depth--;
26520         }
26521         if (flags & NDR_OUT) {
26522                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
26523                 ndr->depth++;
26524                 ndr_print_ptr(ndr, "handle", r->out.handle);
26525                 ndr->depth++;
26526                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26527                 ndr->depth--;
26528                 ndr_print_WERROR(ndr, "result", r->out.result);
26529                 ndr->depth--;
26530         }
26531         ndr->depth--;
26532 }
26533
26534 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
26535 {
26536         if (flags & NDR_IN) {
26537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26538                 if (r->in.server) {
26539                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26542                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26543                 }
26544                 if (r->in.info_ctr == NULL) {
26545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26546                 }
26547                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26548                 if (r->in.devmode_ctr == NULL) {
26549                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26550                 }
26551                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26552                 if (r->in.secdesc_ctr == NULL) {
26553                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26554                 }
26555                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
26556                 if (r->in.userlevel_ctr == NULL) {
26557                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26558                 }
26559                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
26560         }
26561         if (flags & NDR_OUT) {
26562                 if (r->out.handle == NULL) {
26563                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26564                 }
26565                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26566                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26567         }
26568         return NDR_ERR_SUCCESS;
26569 }
26570
26571 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
26572 {
26573         uint32_t _ptr_server;
26574         TALLOC_CTX *_mem_save_server_0;
26575         TALLOC_CTX *_mem_save_info_ctr_0;
26576         TALLOC_CTX *_mem_save_devmode_ctr_0;
26577         TALLOC_CTX *_mem_save_secdesc_ctr_0;
26578         TALLOC_CTX *_mem_save_userlevel_ctr_0;
26579         TALLOC_CTX *_mem_save_handle_0;
26580         if (flags & NDR_IN) {
26581                 ZERO_STRUCT(r->out);
26582
26583                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26584                 if (_ptr_server) {
26585                         NDR_PULL_ALLOC(ndr, r->in.server);
26586                 } else {
26587                         r->in.server = NULL;
26588                 }
26589                 if (r->in.server) {
26590                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26591                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26592                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26593                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26594                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26595                                 return 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));
26596                         }
26597                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26598                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26599                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26600                 }
26601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26602                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26603                 }
26604                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26605                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26606                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26609                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26610                 }
26611                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26612                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26613                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26615                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26616                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
26617                 }
26618                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26619                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
26620                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
26621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26623                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
26624                 }
26625                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26626                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
26627                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
26628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26629                 NDR_PULL_ALLOC(ndr, r->out.handle);
26630                 ZERO_STRUCTP(r->out.handle);
26631         }
26632         if (flags & NDR_OUT) {
26633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26634                         NDR_PULL_ALLOC(ndr, r->out.handle);
26635                 }
26636                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26637                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26638                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26640                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26641         }
26642         return NDR_ERR_SUCCESS;
26643 }
26644
26645 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
26646 {
26647         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
26648         ndr->depth++;
26649         if (flags & NDR_SET_VALUES) {
26650                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26651         }
26652         if (flags & NDR_IN) {
26653                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
26654                 ndr->depth++;
26655                 ndr_print_ptr(ndr, "server", r->in.server);
26656                 ndr->depth++;
26657                 if (r->in.server) {
26658                         ndr_print_string(ndr, "server", r->in.server);
26659                 }
26660                 ndr->depth--;
26661                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26662                 ndr->depth++;
26663                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26664                 ndr->depth--;
26665                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26666                 ndr->depth++;
26667                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26668                 ndr->depth--;
26669                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
26670                 ndr->depth++;
26671                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
26672                 ndr->depth--;
26673                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
26674                 ndr->depth++;
26675                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
26676                 ndr->depth--;
26677                 ndr->depth--;
26678         }
26679         if (flags & NDR_OUT) {
26680                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
26681                 ndr->depth++;
26682                 ndr_print_ptr(ndr, "handle", r->out.handle);
26683                 ndr->depth++;
26684                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26685                 ndr->depth--;
26686                 ndr_print_WERROR(ndr, "result", r->out.result);
26687                 ndr->depth--;
26688         }
26689         ndr->depth--;
26690 }
26691
26692 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
26693 {
26694         if (flags & NDR_IN) {
26695         }
26696         if (flags & NDR_OUT) {
26697                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26698         }
26699         return NDR_ERR_SUCCESS;
26700 }
26701
26702 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
26703 {
26704         if (flags & NDR_IN) {
26705         }
26706         if (flags & NDR_OUT) {
26707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26708         }
26709         return NDR_ERR_SUCCESS;
26710 }
26711
26712 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
26713 {
26714         ndr_print_struct(ndr, name, "spoolss_47");
26715         ndr->depth++;
26716         if (flags & NDR_SET_VALUES) {
26717                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26718         }
26719         if (flags & NDR_IN) {
26720                 ndr_print_struct(ndr, "in", "spoolss_47");
26721                 ndr->depth++;
26722                 ndr->depth--;
26723         }
26724         if (flags & NDR_OUT) {
26725                 ndr_print_struct(ndr, "out", "spoolss_47");
26726                 ndr->depth++;
26727                 ndr_print_WERROR(ndr, "result", r->out.result);
26728                 ndr->depth--;
26729         }
26730         ndr->depth--;
26731 }
26732
26733 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
26734 {
26735         if (flags & NDR_IN) {
26736                 if (r->in.handle == NULL) {
26737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26738                 }
26739                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
26741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
26742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
26743         }
26744         if (flags & NDR_OUT) {
26745                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
26746                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
26747                 if (r->out.value_needed == NULL) {
26748                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26749                 }
26750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
26751                 if (r->out.type == NULL) {
26752                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26753                 }
26754                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26755                 {
26756                         uint32_t _flags_save_uint8 = ndr->flags;
26757                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
26758                         if (r->out.data == NULL) {
26759                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26760                         }
26761                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
26762                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
26763                         ndr->flags = _flags_save_uint8;
26764                 }
26765                 if (r->out.data_needed == NULL) {
26766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26767                 }
26768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
26769                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26770         }
26771         return NDR_ERR_SUCCESS;
26772 }
26773
26774 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
26775 {
26776         TALLOC_CTX *_mem_save_handle_0;
26777         TALLOC_CTX *_mem_save_value_needed_0;
26778         TALLOC_CTX *_mem_save_type_0;
26779         TALLOC_CTX *_mem_save_data_needed_0;
26780         if (flags & NDR_IN) {
26781                 ZERO_STRUCT(r->out);
26782
26783                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26784                         NDR_PULL_ALLOC(ndr, r->in.handle);
26785                 }
26786                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26787                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26788                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26789                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
26791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
26792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
26793                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
26794                 ZERO_STRUCTP(r->out.value_needed);
26795                 NDR_PULL_ALLOC(ndr, r->out.type);
26796                 ZERO_STRUCTP(r->out.type);
26797                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
26798                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
26799                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
26800                 ZERO_STRUCTP(r->out.data_needed);
26801         }
26802         if (flags & NDR_OUT) {
26803                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
26804                 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));
26805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26806                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
26807                 }
26808                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26809                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
26810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
26811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
26812                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26813                         NDR_PULL_ALLOC(ndr, r->out.type);
26814                 }
26815                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26816                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26817                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26818                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26819                 {
26820                         uint32_t _flags_save_uint8 = ndr->flags;
26821                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
26822                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
26823                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26824                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
26825                         }
26826                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
26827                         ndr->flags = _flags_save_uint8;
26828                 }
26829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26830                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
26831                 }
26832                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26833                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
26834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
26835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
26836                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26837                 if (r->out.value_name) {
26838                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
26839                 }
26840                 if (r->out.data) {
26841                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
26842                 }
26843         }
26844         return NDR_ERR_SUCCESS;
26845 }
26846
26847 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
26848 {
26849         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
26850         ndr->depth++;
26851         if (flags & NDR_SET_VALUES) {
26852                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26853         }
26854         if (flags & NDR_IN) {
26855                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
26856                 ndr->depth++;
26857                 ndr_print_ptr(ndr, "handle", r->in.handle);
26858                 ndr->depth++;
26859                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26860                 ndr->depth--;
26861                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
26862                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
26863                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
26864                 ndr->depth--;
26865         }
26866         if (flags & NDR_OUT) {
26867                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
26868                 ndr->depth++;
26869                 ndr_print_string(ndr, "value_name", r->out.value_name);
26870                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
26871                 ndr->depth++;
26872                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
26873                 ndr->depth--;
26874                 ndr_print_ptr(ndr, "type", r->out.type);
26875                 ndr->depth++;
26876                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26877                 ndr->depth--;
26878                 ndr_print_ptr(ndr, "data", r->out.data);
26879                 ndr->depth++;
26880                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
26881                 ndr->depth--;
26882                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
26883                 ndr->depth++;
26884                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
26885                 ndr->depth--;
26886                 ndr_print_WERROR(ndr, "result", r->out.result);
26887                 ndr->depth--;
26888         }
26889         ndr->depth--;
26890 }
26891
26892 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
26893 {
26894         if (flags & NDR_IN) {
26895                 if (r->in.handle == NULL) {
26896                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26897                 }
26898                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26899                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26900                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26901                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26902                 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));
26903         }
26904         if (flags & NDR_OUT) {
26905                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26906         }
26907         return NDR_ERR_SUCCESS;
26908 }
26909
26910 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
26911 {
26912         TALLOC_CTX *_mem_save_handle_0;
26913         if (flags & NDR_IN) {
26914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26915                         NDR_PULL_ALLOC(ndr, r->in.handle);
26916                 }
26917                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26919                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26921                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26922                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26923                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26924                         return 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));
26925                 }
26926                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26927                 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));
26928         }
26929         if (flags & NDR_OUT) {
26930                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26931         }
26932         return NDR_ERR_SUCCESS;
26933 }
26934
26935 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
26936 {
26937         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
26938         ndr->depth++;
26939         if (flags & NDR_SET_VALUES) {
26940                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26941         }
26942         if (flags & NDR_IN) {
26943                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
26944                 ndr->depth++;
26945                 ndr_print_ptr(ndr, "handle", r->in.handle);
26946                 ndr->depth++;
26947                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26948                 ndr->depth--;
26949                 ndr_print_string(ndr, "value_name", r->in.value_name);
26950                 ndr->depth--;
26951         }
26952         if (flags & NDR_OUT) {
26953                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
26954                 ndr->depth++;
26955                 ndr_print_WERROR(ndr, "result", r->out.result);
26956                 ndr->depth--;
26957         }
26958         ndr->depth--;
26959 }
26960
26961 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
26962 {
26963         if (flags & NDR_IN) {
26964         }
26965         if (flags & NDR_OUT) {
26966                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26967         }
26968         return NDR_ERR_SUCCESS;
26969 }
26970
26971 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
26972 {
26973         if (flags & NDR_IN) {
26974         }
26975         if (flags & NDR_OUT) {
26976                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26977         }
26978         return NDR_ERR_SUCCESS;
26979 }
26980
26981 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
26982 {
26983         ndr_print_struct(ndr, name, "spoolss_4a");
26984         ndr->depth++;
26985         if (flags & NDR_SET_VALUES) {
26986                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26987         }
26988         if (flags & NDR_IN) {
26989                 ndr_print_struct(ndr, "in", "spoolss_4a");
26990                 ndr->depth++;
26991                 ndr->depth--;
26992         }
26993         if (flags & NDR_OUT) {
26994                 ndr_print_struct(ndr, "out", "spoolss_4a");
26995                 ndr->depth++;
26996                 ndr_print_WERROR(ndr, "result", r->out.result);
26997                 ndr->depth--;
26998         }
26999         ndr->depth--;
27000 }
27001
27002 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
27003 {
27004         if (flags & NDR_IN) {
27005         }
27006         if (flags & NDR_OUT) {
27007                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27008         }
27009         return NDR_ERR_SUCCESS;
27010 }
27011
27012 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
27013 {
27014         if (flags & NDR_IN) {
27015         }
27016         if (flags & NDR_OUT) {
27017                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27018         }
27019         return NDR_ERR_SUCCESS;
27020 }
27021
27022 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
27023 {
27024         ndr_print_struct(ndr, name, "spoolss_4b");
27025         ndr->depth++;
27026         if (flags & NDR_SET_VALUES) {
27027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27028         }
27029         if (flags & NDR_IN) {
27030                 ndr_print_struct(ndr, "in", "spoolss_4b");
27031                 ndr->depth++;
27032                 ndr->depth--;
27033         }
27034         if (flags & NDR_OUT) {
27035                 ndr_print_struct(ndr, "out", "spoolss_4b");
27036                 ndr->depth++;
27037                 ndr_print_WERROR(ndr, "result", r->out.result);
27038                 ndr->depth--;
27039         }
27040         ndr->depth--;
27041 }
27042
27043 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
27044 {
27045         if (flags & NDR_IN) {
27046         }
27047         if (flags & NDR_OUT) {
27048                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27049         }
27050         return NDR_ERR_SUCCESS;
27051 }
27052
27053 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
27054 {
27055         if (flags & NDR_IN) {
27056         }
27057         if (flags & NDR_OUT) {
27058                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27059         }
27060         return NDR_ERR_SUCCESS;
27061 }
27062
27063 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
27064 {
27065         ndr_print_struct(ndr, name, "spoolss_4c");
27066         ndr->depth++;
27067         if (flags & NDR_SET_VALUES) {
27068                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27069         }
27070         if (flags & NDR_IN) {
27071                 ndr_print_struct(ndr, "in", "spoolss_4c");
27072                 ndr->depth++;
27073                 ndr->depth--;
27074         }
27075         if (flags & NDR_OUT) {
27076                 ndr_print_struct(ndr, "out", "spoolss_4c");
27077                 ndr->depth++;
27078                 ndr_print_WERROR(ndr, "result", r->out.result);
27079                 ndr->depth--;
27080         }
27081         ndr->depth--;
27082 }
27083
27084 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
27085 {
27086         if (flags & NDR_IN) {
27087                 if (r->in.handle == NULL) {
27088                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27089                 }
27090                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27091                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27092                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27093                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27094                 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));
27095                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27096                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27097                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27098                 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));
27099                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27100                 if (r->in.buffer == NULL) {
27101                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27102                 }
27103                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
27104                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
27105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27106         }
27107         if (flags & NDR_OUT) {
27108                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27109         }
27110         return NDR_ERR_SUCCESS;
27111 }
27112
27113 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
27114 {
27115         TALLOC_CTX *_mem_save_handle_0;
27116         if (flags & NDR_IN) {
27117                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27118                         NDR_PULL_ALLOC(ndr, r->in.handle);
27119                 }
27120                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27121                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27122                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27123                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27124                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27125                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27126                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27127                         return 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));
27128                 }
27129                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27130                 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));
27131                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27132                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27133                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27134                         return 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));
27135                 }
27136                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27137                 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));
27138                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27139                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27140                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27141                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
27142                 }
27143                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
27144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27145                 if (r->in.buffer) {
27146                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
27147                 }
27148         }
27149         if (flags & NDR_OUT) {
27150                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27151         }
27152         return NDR_ERR_SUCCESS;
27153 }
27154
27155 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
27156 {
27157         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
27158         ndr->depth++;
27159         if (flags & NDR_SET_VALUES) {
27160                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27161         }
27162         if (flags & NDR_IN) {
27163                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
27164                 ndr->depth++;
27165                 ndr_print_ptr(ndr, "handle", r->in.handle);
27166                 ndr->depth++;
27167                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27168                 ndr->depth--;
27169                 ndr_print_string(ndr, "key_name", r->in.key_name);
27170                 ndr_print_string(ndr, "value_name", r->in.value_name);
27171                 ndr_print_winreg_Type(ndr, "type", r->in.type);
27172                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27173                 ndr->depth++;
27174                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
27175                 ndr->depth--;
27176                 ndr_print_uint32(ndr, "offered", r->in.offered);
27177                 ndr->depth--;
27178         }
27179         if (flags & NDR_OUT) {
27180                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
27181                 ndr->depth++;
27182                 ndr_print_WERROR(ndr, "result", r->out.result);
27183                 ndr->depth--;
27184         }
27185         ndr->depth--;
27186 }
27187
27188 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
27189 {
27190         if (flags & NDR_IN) {
27191                 if (r->in.handle == NULL) {
27192                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27193                 }
27194                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27195                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27196                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27197                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27198                 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));
27199                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27200                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27201                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27202                 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));
27203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27204         }
27205         if (flags & NDR_OUT) {
27206                 if (r->out.type == NULL) {
27207                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27208                 }
27209                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27210                 if (r->out.buffer == NULL) {
27211                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27212                 }
27213                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
27214                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
27215                 if (r->out.needed == NULL) {
27216                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27217                 }
27218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27219                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27220         }
27221         return NDR_ERR_SUCCESS;
27222 }
27223
27224 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
27225 {
27226         TALLOC_CTX *_mem_save_handle_0;
27227         TALLOC_CTX *_mem_save_type_0;
27228         TALLOC_CTX *_mem_save_needed_0;
27229         if (flags & NDR_IN) {
27230                 ZERO_STRUCT(r->out);
27231
27232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27233                         NDR_PULL_ALLOC(ndr, r->in.handle);
27234                 }
27235                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27236                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27237                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27239                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27240                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27241                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27242                         return 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));
27243                 }
27244                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27245                 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));
27246                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27247                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27248                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27249                         return 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));
27250                 }
27251                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27252                 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));
27253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27254                 NDR_PULL_ALLOC(ndr, r->out.type);
27255                 ZERO_STRUCTP(r->out.type);
27256                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
27257                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
27258                 NDR_PULL_ALLOC(ndr, r->out.needed);
27259                 ZERO_STRUCTP(r->out.needed);
27260         }
27261         if (flags & NDR_OUT) {
27262                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27263                         NDR_PULL_ALLOC(ndr, r->out.type);
27264                 }
27265                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27266                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27267                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27268                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27269                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
27270                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27271                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
27272                 }
27273                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
27274                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27275                         NDR_PULL_ALLOC(ndr, r->out.needed);
27276                 }
27277                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27278                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27280                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27281                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27282                 if (r->out.buffer) {
27283                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
27284                 }
27285         }
27286         return NDR_ERR_SUCCESS;
27287 }
27288
27289 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
27290 {
27291         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
27292         ndr->depth++;
27293         if (flags & NDR_SET_VALUES) {
27294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27295         }
27296         if (flags & NDR_IN) {
27297                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
27298                 ndr->depth++;
27299                 ndr_print_ptr(ndr, "handle", r->in.handle);
27300                 ndr->depth++;
27301                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27302                 ndr->depth--;
27303                 ndr_print_string(ndr, "key_name", r->in.key_name);
27304                 ndr_print_string(ndr, "value_name", r->in.value_name);
27305                 ndr_print_uint32(ndr, "offered", r->in.offered);
27306                 ndr->depth--;
27307         }
27308         if (flags & NDR_OUT) {
27309                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
27310                 ndr->depth++;
27311                 ndr_print_ptr(ndr, "type", r->out.type);
27312                 ndr->depth++;
27313                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27314                 ndr->depth--;
27315                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
27316                 ndr->depth++;
27317                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
27318                 ndr->depth--;
27319                 ndr_print_ptr(ndr, "needed", r->out.needed);
27320                 ndr->depth++;
27321                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27322                 ndr->depth--;
27323                 ndr_print_WERROR(ndr, "result", r->out.result);
27324                 ndr->depth--;
27325         }
27326         ndr->depth--;
27327 }
27328
27329 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
27330 {
27331         if (flags & NDR_IN) {
27332                 if (r->in.handle == NULL) {
27333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27334                 }
27335                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27336                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27337                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27338                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27339                 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));
27340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27341         }
27342         if (flags & NDR_OUT) {
27343                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
27344                 if (r->out.needed == NULL) {
27345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27346                 }
27347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27348                 if (r->out.count == NULL) {
27349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27350                 }
27351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
27352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27353         }
27354         return NDR_ERR_SUCCESS;
27355 }
27356
27357 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
27358 {
27359         TALLOC_CTX *_mem_save_handle_0;
27360         TALLOC_CTX *_mem_save_needed_0;
27361         TALLOC_CTX *_mem_save_count_0;
27362         if (flags & NDR_IN) {
27363                 ZERO_STRUCT(r->out);
27364
27365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27366                         NDR_PULL_ALLOC(ndr, r->in.handle);
27367                 }
27368                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27370                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27372                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27373                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27374                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27375                         return 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));
27376                 }
27377                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27378                 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));
27379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27380                 NDR_PULL_ALLOC(ndr, r->out.needed);
27381                 ZERO_STRUCTP(r->out.needed);
27382                 NDR_PULL_ALLOC(ndr, r->out.count);
27383                 ZERO_STRUCTP(r->out.count);
27384         }
27385         if (flags & NDR_OUT) {
27386                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
27387                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27388                         NDR_PULL_ALLOC(ndr, r->out.needed);
27389                 }
27390                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27391                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27393                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27395                         NDR_PULL_ALLOC(ndr, r->out.count);
27396                 }
27397                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
27398                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
27399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
27400                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
27401                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27402         }
27403         return NDR_ERR_SUCCESS;
27404 }
27405
27406 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
27407 {
27408         uint32_t cntr_info_0;
27409         if (flags & NDR_IN) {
27410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
27411         }
27412         if (flags & NDR_OUT) {
27413                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27414                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27415                 }
27416                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27417                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27418                 }
27419         }
27420         return NDR_ERR_SUCCESS;
27421 }
27422
27423 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
27424 {
27425         uint32_t cntr_info_0;
27426         TALLOC_CTX *_mem_save_info_0;
27427         if (flags & NDR_IN) {
27428                 ZERO_STRUCT(r->out);
27429
27430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
27431         }
27432         if (flags & NDR_OUT) {
27433                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
27434                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27435                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
27436                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27437                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
27438                 }
27439                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
27440                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
27441                 }
27442                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
27443         }
27444         return NDR_ERR_SUCCESS;
27445 }
27446
27447 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
27448 {
27449         uint32_t cntr_info_2;
27450         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
27451         ndr->depth++;
27452         if (flags & NDR_SET_VALUES) {
27453                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27454         }
27455         if (flags & NDR_IN) {
27456                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
27457                 ndr->depth++;
27458                 ndr_print_ptr(ndr, "handle", r->in.handle);
27459                 ndr->depth++;
27460                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27461                 ndr->depth--;
27462                 ndr_print_string(ndr, "key_name", r->in.key_name);
27463                 ndr_print_uint32(ndr, "offered", r->in.offered);
27464                 ndr->depth--;
27465         }
27466         if (flags & NDR_OUT) {
27467                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
27468                 ndr->depth++;
27469                 ndr_print_ptr(ndr, "count", r->out.count);
27470                 ndr->depth++;
27471                 ndr_print_uint32(ndr, "count", *r->out.count);
27472                 ndr->depth--;
27473                 ndr_print_ptr(ndr, "info", r->out.info);
27474                 ndr->depth++;
27475                 ndr_print_ptr(ndr, "info", *r->out.info);
27476                 ndr->depth++;
27477                 if (*r->out.info) {
27478                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
27479                         ndr->depth++;
27480                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
27481                                 char *idx_2=NULL;
27482                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
27483                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
27484                                         free(idx_2);
27485                                 }
27486                         }
27487                         ndr->depth--;
27488                 }
27489                 ndr->depth--;
27490                 ndr->depth--;
27491                 ndr_print_ptr(ndr, "needed", r->out.needed);
27492                 ndr->depth++;
27493                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27494                 ndr->depth--;
27495                 ndr_print_WERROR(ndr, "result", r->out.result);
27496                 ndr->depth--;
27497         }
27498         ndr->depth--;
27499 }
27500
27501 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
27502 {
27503         if (flags & NDR_IN) {
27504                 if (r->in.handle == NULL) {
27505                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27506                 }
27507                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27508                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27509                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27510                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27511                 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));
27512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27513         }
27514         if (flags & NDR_OUT) {
27515                 {
27516                         uint32_t _flags_save_string_array = ndr->flags;
27517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
27518                         if (r->out.key_buffer == NULL) {
27519                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27520                         }
27521                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_buffer));
27522                         if (*r->out.key_buffer) {
27523                                 {
27524                                         struct ndr_push *_ndr_key_buffer;
27525                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
27526                                         NDR_CHECK(ndr_push_string_array(_ndr_key_buffer, NDR_SCALARS, *r->out.key_buffer));
27527                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
27528                                 }
27529                         }
27530                         ndr->flags = _flags_save_string_array;
27531                 }
27532                 if (r->out.needed == NULL) {
27533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27534                 }
27535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27536                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27537         }
27538         return NDR_ERR_SUCCESS;
27539 }
27540
27541 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
27542 {
27543         uint32_t _ptr_key_buffer;
27544         TALLOC_CTX *_mem_save_handle_0;
27545         TALLOC_CTX *_mem_save_key_buffer_0;
27546         TALLOC_CTX *_mem_save_key_buffer_1;
27547         TALLOC_CTX *_mem_save_needed_0;
27548         if (flags & NDR_IN) {
27549                 ZERO_STRUCT(r->out);
27550
27551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27552                         NDR_PULL_ALLOC(ndr, r->in.handle);
27553                 }
27554                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27555                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27556                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27558                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27559                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27560                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27561                         return 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));
27562                 }
27563                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27564                 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));
27565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27566                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
27567                 ZERO_STRUCTP(r->out.key_buffer);
27568                 NDR_PULL_ALLOC(ndr, r->out.needed);
27569                 ZERO_STRUCTP(r->out.needed);
27570         }
27571         if (flags & NDR_OUT) {
27572                 {
27573                         uint32_t _flags_save_string_array = ndr->flags;
27574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
27575                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27576                                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
27577                         }
27578                         _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27579                         NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
27580                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_buffer));
27581                         if (_ptr_key_buffer) {
27582                                 NDR_PULL_ALLOC(ndr, *r->out.key_buffer);
27583                         } else {
27584                                 *r->out.key_buffer = NULL;
27585                         }
27586                         if (*r->out.key_buffer) {
27587                                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
27588                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_buffer, 0);
27589                                 {
27590                                         struct ndr_pull *_ndr_key_buffer;
27591                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
27592                                         NDR_CHECK(ndr_pull_string_array(_ndr_key_buffer, NDR_SCALARS, r->out.key_buffer));
27593                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
27594                                 }
27595                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
27596                         }
27597                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
27598                         ndr->flags = _flags_save_string_array;
27599                 }
27600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27601                         NDR_PULL_ALLOC(ndr, r->out.needed);
27602                 }
27603                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27604                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27607                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27608         }
27609         return NDR_ERR_SUCCESS;
27610 }
27611
27612 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
27613 {
27614         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
27615         ndr->depth++;
27616         if (flags & NDR_SET_VALUES) {
27617                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27618         }
27619         if (flags & NDR_IN) {
27620                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
27621                 ndr->depth++;
27622                 ndr_print_ptr(ndr, "handle", r->in.handle);
27623                 ndr->depth++;
27624                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27625                 ndr->depth--;
27626                 ndr_print_string(ndr, "key_name", r->in.key_name);
27627                 ndr_print_uint32(ndr, "offered", r->in.offered);
27628                 ndr->depth--;
27629         }
27630         if (flags & NDR_OUT) {
27631                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
27632                 ndr->depth++;
27633                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
27634                 ndr->depth++;
27635                 ndr_print_ptr(ndr, "key_buffer", *r->out.key_buffer);
27636                 ndr->depth++;
27637                 if (*r->out.key_buffer) {
27638                         ndr_print_string_array(ndr, "key_buffer", *r->out.key_buffer);
27639                 }
27640                 ndr->depth--;
27641                 ndr->depth--;
27642                 ndr_print_ptr(ndr, "needed", r->out.needed);
27643                 ndr->depth++;
27644                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27645                 ndr->depth--;
27646                 ndr_print_WERROR(ndr, "result", r->out.result);
27647                 ndr->depth--;
27648         }
27649         ndr->depth--;
27650 }
27651
27652 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
27653 {
27654         if (flags & NDR_IN) {
27655                 if (r->in.handle == NULL) {
27656                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27657                 }
27658                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27659                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27660                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27661                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27662                 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));
27663                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27664                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27665                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27666                 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));
27667         }
27668         if (flags & NDR_OUT) {
27669                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27670         }
27671         return NDR_ERR_SUCCESS;
27672 }
27673
27674 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
27675 {
27676         TALLOC_CTX *_mem_save_handle_0;
27677         if (flags & NDR_IN) {
27678                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27679                         NDR_PULL_ALLOC(ndr, r->in.handle);
27680                 }
27681                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27682                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27683                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27684                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27685                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27686                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27687                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27688                         return 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));
27689                 }
27690                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27691                 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));
27692                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27693                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27694                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27695                         return 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));
27696                 }
27697                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27698                 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));
27699         }
27700         if (flags & NDR_OUT) {
27701                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27702         }
27703         return NDR_ERR_SUCCESS;
27704 }
27705
27706 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
27707 {
27708         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
27709         ndr->depth++;
27710         if (flags & NDR_SET_VALUES) {
27711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27712         }
27713         if (flags & NDR_IN) {
27714                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
27715                 ndr->depth++;
27716                 ndr_print_ptr(ndr, "handle", r->in.handle);
27717                 ndr->depth++;
27718                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27719                 ndr->depth--;
27720                 ndr_print_string(ndr, "key_name", r->in.key_name);
27721                 ndr_print_string(ndr, "value_name", r->in.value_name);
27722                 ndr->depth--;
27723         }
27724         if (flags & NDR_OUT) {
27725                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
27726                 ndr->depth++;
27727                 ndr_print_WERROR(ndr, "result", r->out.result);
27728                 ndr->depth--;
27729         }
27730         ndr->depth--;
27731 }
27732
27733 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
27734 {
27735         if (flags & NDR_IN) {
27736                 if (r->in.handle == NULL) {
27737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27738                 }
27739                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27740                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27741                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27742                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27743                 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));
27744         }
27745         if (flags & NDR_OUT) {
27746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27747         }
27748         return NDR_ERR_SUCCESS;
27749 }
27750
27751 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
27752 {
27753         TALLOC_CTX *_mem_save_handle_0;
27754         if (flags & NDR_IN) {
27755                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27756                         NDR_PULL_ALLOC(ndr, r->in.handle);
27757                 }
27758                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27759                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27760                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27762                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27763                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27764                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27765                         return 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));
27766                 }
27767                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27768                 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));
27769         }
27770         if (flags & NDR_OUT) {
27771                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27772         }
27773         return NDR_ERR_SUCCESS;
27774 }
27775
27776 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
27777 {
27778         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
27779         ndr->depth++;
27780         if (flags & NDR_SET_VALUES) {
27781                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27782         }
27783         if (flags & NDR_IN) {
27784                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
27785                 ndr->depth++;
27786                 ndr_print_ptr(ndr, "handle", r->in.handle);
27787                 ndr->depth++;
27788                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27789                 ndr->depth--;
27790                 ndr_print_string(ndr, "key_name", r->in.key_name);
27791                 ndr->depth--;
27792         }
27793         if (flags & NDR_OUT) {
27794                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
27795                 ndr->depth++;
27796                 ndr_print_WERROR(ndr, "result", r->out.result);
27797                 ndr->depth--;
27798         }
27799         ndr->depth--;
27800 }
27801
27802 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
27803 {
27804         if (flags & NDR_IN) {
27805         }
27806         if (flags & NDR_OUT) {
27807                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27808         }
27809         return NDR_ERR_SUCCESS;
27810 }
27811
27812 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
27813 {
27814         if (flags & NDR_IN) {
27815         }
27816         if (flags & NDR_OUT) {
27817                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27818         }
27819         return NDR_ERR_SUCCESS;
27820 }
27821
27822 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
27823 {
27824         ndr_print_struct(ndr, name, "spoolss_53");
27825         ndr->depth++;
27826         if (flags & NDR_SET_VALUES) {
27827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27828         }
27829         if (flags & NDR_IN) {
27830                 ndr_print_struct(ndr, "in", "spoolss_53");
27831                 ndr->depth++;
27832                 ndr->depth--;
27833         }
27834         if (flags & NDR_OUT) {
27835                 ndr_print_struct(ndr, "out", "spoolss_53");
27836                 ndr->depth++;
27837                 ndr_print_WERROR(ndr, "result", r->out.result);
27838                 ndr->depth--;
27839         }
27840         ndr->depth--;
27841 }
27842
27843 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27844 {
27845         if (flags & NDR_IN) {
27846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27847                 if (r->in.server) {
27848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27849                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27851                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27852                 }
27853                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27854                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27855                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27856                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27857                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27858                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27859                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27860                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27861                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
27862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
27863         }
27864         if (flags & NDR_OUT) {
27865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27866         }
27867         return NDR_ERR_SUCCESS;
27868 }
27869
27870 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
27871 {
27872         uint32_t _ptr_server;
27873         TALLOC_CTX *_mem_save_server_0;
27874         if (flags & NDR_IN) {
27875                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27876                 if (_ptr_server) {
27877                         NDR_PULL_ALLOC(ndr, r->in.server);
27878                 } else {
27879                         r->in.server = NULL;
27880                 }
27881                 if (r->in.server) {
27882                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27883                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27884                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27885                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27886                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27887                                 return 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));
27888                         }
27889                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27890                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27891                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27892                 }
27893                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
27894                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
27895                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
27896                         return 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));
27897                 }
27898                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
27899                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
27900                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
27901                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
27902                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
27903                         return 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));
27904                 }
27905                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
27906                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
27907                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
27908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
27909         }
27910         if (flags & NDR_OUT) {
27911                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27912         }
27913         return NDR_ERR_SUCCESS;
27914 }
27915
27916 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27917 {
27918         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
27919         ndr->depth++;
27920         if (flags & NDR_SET_VALUES) {
27921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27922         }
27923         if (flags & NDR_IN) {
27924                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
27925                 ndr->depth++;
27926                 ndr_print_ptr(ndr, "server", r->in.server);
27927                 ndr->depth++;
27928                 if (r->in.server) {
27929                         ndr_print_string(ndr, "server", r->in.server);
27930                 }
27931                 ndr->depth--;
27932                 ndr_print_string(ndr, "architecture", r->in.architecture);
27933                 ndr_print_string(ndr, "driver", r->in.driver);
27934                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
27935                 ndr_print_uint32(ndr, "version", r->in.version);
27936                 ndr->depth--;
27937         }
27938         if (flags & NDR_OUT) {
27939                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
27940                 ndr->depth++;
27941                 ndr_print_WERROR(ndr, "result", r->out.result);
27942                 ndr->depth--;
27943         }
27944         ndr->depth--;
27945 }
27946
27947 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
27948 {
27949         if (flags & NDR_IN) {
27950         }
27951         if (flags & NDR_OUT) {
27952                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27953         }
27954         return NDR_ERR_SUCCESS;
27955 }
27956
27957 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
27958 {
27959         if (flags & NDR_IN) {
27960         }
27961         if (flags & NDR_OUT) {
27962                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27963         }
27964         return NDR_ERR_SUCCESS;
27965 }
27966
27967 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
27968 {
27969         ndr_print_struct(ndr, name, "spoolss_55");
27970         ndr->depth++;
27971         if (flags & NDR_SET_VALUES) {
27972                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27973         }
27974         if (flags & NDR_IN) {
27975                 ndr_print_struct(ndr, "in", "spoolss_55");
27976                 ndr->depth++;
27977                 ndr->depth--;
27978         }
27979         if (flags & NDR_OUT) {
27980                 ndr_print_struct(ndr, "out", "spoolss_55");
27981                 ndr->depth++;
27982                 ndr_print_WERROR(ndr, "result", r->out.result);
27983                 ndr->depth--;
27984         }
27985         ndr->depth--;
27986 }
27987
27988 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
27989 {
27990         if (flags & NDR_IN) {
27991         }
27992         if (flags & NDR_OUT) {
27993                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27994         }
27995         return NDR_ERR_SUCCESS;
27996 }
27997
27998 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
27999 {
28000         if (flags & NDR_IN) {
28001         }
28002         if (flags & NDR_OUT) {
28003                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28004         }
28005         return NDR_ERR_SUCCESS;
28006 }
28007
28008 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
28009 {
28010         ndr_print_struct(ndr, name, "spoolss_56");
28011         ndr->depth++;
28012         if (flags & NDR_SET_VALUES) {
28013                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28014         }
28015         if (flags & NDR_IN) {
28016                 ndr_print_struct(ndr, "in", "spoolss_56");
28017                 ndr->depth++;
28018                 ndr->depth--;
28019         }
28020         if (flags & NDR_OUT) {
28021                 ndr_print_struct(ndr, "out", "spoolss_56");
28022                 ndr->depth++;
28023                 ndr_print_WERROR(ndr, "result", r->out.result);
28024                 ndr->depth--;
28025         }
28026         ndr->depth--;
28027 }
28028
28029 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
28030 {
28031         if (flags & NDR_IN) {
28032         }
28033         if (flags & NDR_OUT) {
28034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28035         }
28036         return NDR_ERR_SUCCESS;
28037 }
28038
28039 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
28040 {
28041         if (flags & NDR_IN) {
28042         }
28043         if (flags & NDR_OUT) {
28044                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28045         }
28046         return NDR_ERR_SUCCESS;
28047 }
28048
28049 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
28050 {
28051         ndr_print_struct(ndr, name, "spoolss_57");
28052         ndr->depth++;
28053         if (flags & NDR_SET_VALUES) {
28054                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28055         }
28056         if (flags & NDR_IN) {
28057                 ndr_print_struct(ndr, "in", "spoolss_57");
28058                 ndr->depth++;
28059                 ndr->depth--;
28060         }
28061         if (flags & NDR_OUT) {
28062                 ndr_print_struct(ndr, "out", "spoolss_57");
28063                 ndr->depth++;
28064                 ndr_print_WERROR(ndr, "result", r->out.result);
28065                 ndr->depth--;
28066         }
28067         ndr->depth--;
28068 }
28069
28070 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
28071 {
28072         if (flags & NDR_IN) {
28073                 if (r->in.handle == NULL) {
28074                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28075                 }
28076                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28077                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28078                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28079                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28080                 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));
28081                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
28082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
28083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
28084                 if (r->in.status_code == NULL) {
28085                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28086                 }
28087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
28088         }
28089         if (flags & NDR_OUT) {
28090                 if (r->out.out_data == NULL) {
28091                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28092                 }
28093                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
28094                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
28095                 if (r->out.needed == NULL) {
28096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28097                 }
28098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28099                 if (r->out.status_code == NULL) {
28100                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28101                 }
28102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
28103                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28104         }
28105         return NDR_ERR_SUCCESS;
28106 }
28107
28108 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
28109 {
28110         TALLOC_CTX *_mem_save_handle_0;
28111         TALLOC_CTX *_mem_save_needed_0;
28112         TALLOC_CTX *_mem_save_status_code_0;
28113         if (flags & NDR_IN) {
28114                 ZERO_STRUCT(r->out);
28115
28116                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28117                         NDR_PULL_ALLOC(ndr, r->in.handle);
28118                 }
28119                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28120                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28121                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28122                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28123                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
28124                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
28125                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
28126                         return 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));
28127                 }
28128                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
28129                 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));
28130                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
28131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
28132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
28133                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28134                         NDR_PULL_ALLOC(ndr, r->in.status_code);
28135                 }
28136                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28137                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
28138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
28139                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28140                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
28141                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
28142                 NDR_PULL_ALLOC(ndr, r->out.needed);
28143                 ZERO_STRUCTP(r->out.needed);
28144                 NDR_PULL_ALLOC(ndr, r->out.status_code);
28145                 *r->out.status_code = *r->in.status_code;
28146         }
28147         if (flags & NDR_OUT) {
28148                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
28149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28150                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
28151                 }
28152                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
28153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28154                         NDR_PULL_ALLOC(ndr, r->out.needed);
28155                 }
28156                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28157                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28161                         NDR_PULL_ALLOC(ndr, r->out.status_code);
28162                 }
28163                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28164                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
28165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
28166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28167                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28168                 if (r->out.out_data) {
28169                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
28170                 }
28171         }
28172         return NDR_ERR_SUCCESS;
28173 }
28174
28175 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
28176 {
28177         ndr_print_struct(ndr, name, "spoolss_XcvData");
28178         ndr->depth++;
28179         if (flags & NDR_SET_VALUES) {
28180                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28181         }
28182         if (flags & NDR_IN) {
28183                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
28184                 ndr->depth++;
28185                 ndr_print_ptr(ndr, "handle", r->in.handle);
28186                 ndr->depth++;
28187                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28188                 ndr->depth--;
28189                 ndr_print_string(ndr, "function_name", r->in.function_name);
28190                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
28191                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
28192                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
28193                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
28194                 ndr->depth++;
28195                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
28196                 ndr->depth--;
28197                 ndr->depth--;
28198         }
28199         if (flags & NDR_OUT) {
28200                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
28201                 ndr->depth++;
28202                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
28203                 ndr->depth++;
28204                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
28205                 ndr->depth--;
28206                 ndr_print_ptr(ndr, "needed", r->out.needed);
28207                 ndr->depth++;
28208                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28209                 ndr->depth--;
28210                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
28211                 ndr->depth++;
28212                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
28213                 ndr->depth--;
28214                 ndr_print_WERROR(ndr, "result", r->out.result);
28215                 ndr->depth--;
28216         }
28217         ndr->depth--;
28218 }
28219
28220 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
28221 {
28222         if (flags & NDR_IN) {
28223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
28224                 if (r->in.servername) {
28225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28226                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28227                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28228                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28229                 }
28230                 if (r->in.info_ctr == NULL) {
28231                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28232                 }
28233                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28234                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
28235         }
28236         if (flags & NDR_OUT) {
28237                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28238         }
28239         return NDR_ERR_SUCCESS;
28240 }
28241
28242 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
28243 {
28244         uint32_t _ptr_servername;
28245         TALLOC_CTX *_mem_save_servername_0;
28246         TALLOC_CTX *_mem_save_info_ctr_0;
28247         if (flags & NDR_IN) {
28248                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
28249                 if (_ptr_servername) {
28250                         NDR_PULL_ALLOC(ndr, r->in.servername);
28251                 } else {
28252                         r->in.servername = NULL;
28253                 }
28254                 if (r->in.servername) {
28255                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
28256                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
28257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
28258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
28259                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
28260                                 return 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));
28261                         }
28262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
28263                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
28264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
28265                 }
28266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28267                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
28268                 }
28269                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28270                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
28271                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28273                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
28274         }
28275         if (flags & NDR_OUT) {
28276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28277         }
28278         return NDR_ERR_SUCCESS;
28279 }
28280
28281 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
28282 {
28283         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
28284         ndr->depth++;
28285         if (flags & NDR_SET_VALUES) {
28286                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28287         }
28288         if (flags & NDR_IN) {
28289                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
28290                 ndr->depth++;
28291                 ndr_print_ptr(ndr, "servername", r->in.servername);
28292                 ndr->depth++;
28293                 if (r->in.servername) {
28294                         ndr_print_string(ndr, "servername", r->in.servername);
28295                 }
28296                 ndr->depth--;
28297                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28298                 ndr->depth++;
28299                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28300                 ndr->depth--;
28301                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
28302                 ndr->depth--;
28303         }
28304         if (flags & NDR_OUT) {
28305                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
28306                 ndr->depth++;
28307                 ndr_print_WERROR(ndr, "result", r->out.result);
28308                 ndr->depth--;
28309         }
28310         ndr->depth--;
28311 }
28312
28313 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
28314 {
28315         if (flags & NDR_IN) {
28316         }
28317         if (flags & NDR_OUT) {
28318                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28319         }
28320         return NDR_ERR_SUCCESS;
28321 }
28322
28323 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
28324 {
28325         if (flags & NDR_IN) {
28326         }
28327         if (flags & NDR_OUT) {
28328                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28329         }
28330         return NDR_ERR_SUCCESS;
28331 }
28332
28333 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
28334 {
28335         ndr_print_struct(ndr, name, "spoolss_5a");
28336         ndr->depth++;
28337         if (flags & NDR_SET_VALUES) {
28338                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28339         }
28340         if (flags & NDR_IN) {
28341                 ndr_print_struct(ndr, "in", "spoolss_5a");
28342                 ndr->depth++;
28343                 ndr->depth--;
28344         }
28345         if (flags & NDR_OUT) {
28346                 ndr_print_struct(ndr, "out", "spoolss_5a");
28347                 ndr->depth++;
28348                 ndr_print_WERROR(ndr, "result", r->out.result);
28349                 ndr->depth--;
28350         }
28351         ndr->depth--;
28352 }
28353
28354 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
28355 {
28356         if (flags & NDR_IN) {
28357         }
28358         if (flags & NDR_OUT) {
28359                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28360         }
28361         return NDR_ERR_SUCCESS;
28362 }
28363
28364 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
28365 {
28366         if (flags & NDR_IN) {
28367         }
28368         if (flags & NDR_OUT) {
28369                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28370         }
28371         return NDR_ERR_SUCCESS;
28372 }
28373
28374 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
28375 {
28376         ndr_print_struct(ndr, name, "spoolss_5b");
28377         ndr->depth++;
28378         if (flags & NDR_SET_VALUES) {
28379                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28380         }
28381         if (flags & NDR_IN) {
28382                 ndr_print_struct(ndr, "in", "spoolss_5b");
28383                 ndr->depth++;
28384                 ndr->depth--;
28385         }
28386         if (flags & NDR_OUT) {
28387                 ndr_print_struct(ndr, "out", "spoolss_5b");
28388                 ndr->depth++;
28389                 ndr_print_WERROR(ndr, "result", r->out.result);
28390                 ndr->depth--;
28391         }
28392         ndr->depth--;
28393 }
28394
28395 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
28396 {
28397         if (flags & NDR_IN) {
28398         }
28399         if (flags & NDR_OUT) {
28400                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28401         }
28402         return NDR_ERR_SUCCESS;
28403 }
28404
28405 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
28406 {
28407         if (flags & NDR_IN) {
28408         }
28409         if (flags & NDR_OUT) {
28410                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28411         }
28412         return NDR_ERR_SUCCESS;
28413 }
28414
28415 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
28416 {
28417         ndr_print_struct(ndr, name, "spoolss_5c");
28418         ndr->depth++;
28419         if (flags & NDR_SET_VALUES) {
28420                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28421         }
28422         if (flags & NDR_IN) {
28423                 ndr_print_struct(ndr, "in", "spoolss_5c");
28424                 ndr->depth++;
28425                 ndr->depth--;
28426         }
28427         if (flags & NDR_OUT) {
28428                 ndr_print_struct(ndr, "out", "spoolss_5c");
28429                 ndr->depth++;
28430                 ndr_print_WERROR(ndr, "result", r->out.result);
28431                 ndr->depth--;
28432         }
28433         ndr->depth--;
28434 }
28435
28436 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
28437 {
28438         if (flags & NDR_IN) {
28439         }
28440         if (flags & NDR_OUT) {
28441                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28442         }
28443         return NDR_ERR_SUCCESS;
28444 }
28445
28446 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
28447 {
28448         if (flags & NDR_IN) {
28449         }
28450         if (flags & NDR_OUT) {
28451                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28452         }
28453         return NDR_ERR_SUCCESS;
28454 }
28455
28456 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
28457 {
28458         ndr_print_struct(ndr, name, "spoolss_5d");
28459         ndr->depth++;
28460         if (flags & NDR_SET_VALUES) {
28461                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28462         }
28463         if (flags & NDR_IN) {
28464                 ndr_print_struct(ndr, "in", "spoolss_5d");
28465                 ndr->depth++;
28466                 ndr->depth--;
28467         }
28468         if (flags & NDR_OUT) {
28469                 ndr_print_struct(ndr, "out", "spoolss_5d");
28470                 ndr->depth++;
28471                 ndr_print_WERROR(ndr, "result", r->out.result);
28472                 ndr->depth--;
28473         }
28474         ndr->depth--;
28475 }
28476
28477 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
28478 {
28479         if (flags & NDR_IN) {
28480         }
28481         if (flags & NDR_OUT) {
28482                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28483         }
28484         return NDR_ERR_SUCCESS;
28485 }
28486
28487 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
28488 {
28489         if (flags & NDR_IN) {
28490         }
28491         if (flags & NDR_OUT) {
28492                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28493         }
28494         return NDR_ERR_SUCCESS;
28495 }
28496
28497 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
28498 {
28499         ndr_print_struct(ndr, name, "spoolss_5e");
28500         ndr->depth++;
28501         if (flags & NDR_SET_VALUES) {
28502                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28503         }
28504         if (flags & NDR_IN) {
28505                 ndr_print_struct(ndr, "in", "spoolss_5e");
28506                 ndr->depth++;
28507                 ndr->depth--;
28508         }
28509         if (flags & NDR_OUT) {
28510                 ndr_print_struct(ndr, "out", "spoolss_5e");
28511                 ndr->depth++;
28512                 ndr_print_WERROR(ndr, "result", r->out.result);
28513                 ndr->depth--;
28514         }
28515         ndr->depth--;
28516 }
28517
28518 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
28519 {
28520         if (flags & NDR_IN) {
28521         }
28522         if (flags & NDR_OUT) {
28523                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28524         }
28525         return NDR_ERR_SUCCESS;
28526 }
28527
28528 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
28529 {
28530         if (flags & NDR_IN) {
28531         }
28532         if (flags & NDR_OUT) {
28533                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28534         }
28535         return NDR_ERR_SUCCESS;
28536 }
28537
28538 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
28539 {
28540         ndr_print_struct(ndr, name, "spoolss_5f");
28541         ndr->depth++;
28542         if (flags & NDR_SET_VALUES) {
28543                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28544         }
28545         if (flags & NDR_IN) {
28546                 ndr_print_struct(ndr, "in", "spoolss_5f");
28547                 ndr->depth++;
28548                 ndr->depth--;
28549         }
28550         if (flags & NDR_OUT) {
28551                 ndr_print_struct(ndr, "out", "spoolss_5f");
28552                 ndr->depth++;
28553                 ndr_print_WERROR(ndr, "result", r->out.result);
28554                 ndr->depth--;
28555         }
28556         ndr->depth--;
28557 }
28558
28559 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
28560 {
28561         if (flags & NDR_IN) {
28562         }
28563         if (flags & NDR_OUT) {
28564                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28565         }
28566         return NDR_ERR_SUCCESS;
28567 }
28568
28569 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
28570 {
28571         if (flags & NDR_IN) {
28572         }
28573         if (flags & NDR_OUT) {
28574                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28575         }
28576         return NDR_ERR_SUCCESS;
28577 }
28578
28579 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
28580 {
28581         ndr_print_struct(ndr, name, "spoolss_60");
28582         ndr->depth++;
28583         if (flags & NDR_SET_VALUES) {
28584                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28585         }
28586         if (flags & NDR_IN) {
28587                 ndr_print_struct(ndr, "in", "spoolss_60");
28588                 ndr->depth++;
28589                 ndr->depth--;
28590         }
28591         if (flags & NDR_OUT) {
28592                 ndr_print_struct(ndr, "out", "spoolss_60");
28593                 ndr->depth++;
28594                 ndr_print_WERROR(ndr, "result", r->out.result);
28595                 ndr->depth--;
28596         }
28597         ndr->depth--;
28598 }
28599
28600 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
28601 {
28602         if (flags & NDR_IN) {
28603         }
28604         if (flags & NDR_OUT) {
28605                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28606         }
28607         return NDR_ERR_SUCCESS;
28608 }
28609
28610 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
28611 {
28612         if (flags & NDR_IN) {
28613         }
28614         if (flags & NDR_OUT) {
28615                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28616         }
28617         return NDR_ERR_SUCCESS;
28618 }
28619
28620 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
28621 {
28622         ndr_print_struct(ndr, name, "spoolss_61");
28623         ndr->depth++;
28624         if (flags & NDR_SET_VALUES) {
28625                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28626         }
28627         if (flags & NDR_IN) {
28628                 ndr_print_struct(ndr, "in", "spoolss_61");
28629                 ndr->depth++;
28630                 ndr->depth--;
28631         }
28632         if (flags & NDR_OUT) {
28633                 ndr_print_struct(ndr, "out", "spoolss_61");
28634                 ndr->depth++;
28635                 ndr_print_WERROR(ndr, "result", r->out.result);
28636                 ndr->depth--;
28637         }
28638         ndr->depth--;
28639 }
28640
28641 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
28642 {
28643         if (flags & NDR_IN) {
28644         }
28645         if (flags & NDR_OUT) {
28646                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28647         }
28648         return NDR_ERR_SUCCESS;
28649 }
28650
28651 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
28652 {
28653         if (flags & NDR_IN) {
28654         }
28655         if (flags & NDR_OUT) {
28656                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28657         }
28658         return NDR_ERR_SUCCESS;
28659 }
28660
28661 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
28662 {
28663         ndr_print_struct(ndr, name, "spoolss_62");
28664         ndr->depth++;
28665         if (flags & NDR_SET_VALUES) {
28666                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28667         }
28668         if (flags & NDR_IN) {
28669                 ndr_print_struct(ndr, "in", "spoolss_62");
28670                 ndr->depth++;
28671                 ndr->depth--;
28672         }
28673         if (flags & NDR_OUT) {
28674                 ndr_print_struct(ndr, "out", "spoolss_62");
28675                 ndr->depth++;
28676                 ndr_print_WERROR(ndr, "result", r->out.result);
28677                 ndr->depth--;
28678         }
28679         ndr->depth--;
28680 }
28681
28682 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
28683 {
28684         if (flags & NDR_IN) {
28685         }
28686         if (flags & NDR_OUT) {
28687                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28688         }
28689         return NDR_ERR_SUCCESS;
28690 }
28691
28692 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
28693 {
28694         if (flags & NDR_IN) {
28695         }
28696         if (flags & NDR_OUT) {
28697                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28698         }
28699         return NDR_ERR_SUCCESS;
28700 }
28701
28702 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
28703 {
28704         ndr_print_struct(ndr, name, "spoolss_63");
28705         ndr->depth++;
28706         if (flags & NDR_SET_VALUES) {
28707                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28708         }
28709         if (flags & NDR_IN) {
28710                 ndr_print_struct(ndr, "in", "spoolss_63");
28711                 ndr->depth++;
28712                 ndr->depth--;
28713         }
28714         if (flags & NDR_OUT) {
28715                 ndr_print_struct(ndr, "out", "spoolss_63");
28716                 ndr->depth++;
28717                 ndr_print_WERROR(ndr, "result", r->out.result);
28718                 ndr->depth--;
28719         }
28720         ndr->depth--;
28721 }
28722
28723 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
28724 {
28725         if (flags & NDR_IN) {
28726         }
28727         if (flags & NDR_OUT) {
28728                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28729         }
28730         return NDR_ERR_SUCCESS;
28731 }
28732
28733 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
28734 {
28735         if (flags & NDR_IN) {
28736         }
28737         if (flags & NDR_OUT) {
28738                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28739         }
28740         return NDR_ERR_SUCCESS;
28741 }
28742
28743 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
28744 {
28745         ndr_print_struct(ndr, name, "spoolss_64");
28746         ndr->depth++;
28747         if (flags & NDR_SET_VALUES) {
28748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28749         }
28750         if (flags & NDR_IN) {
28751                 ndr_print_struct(ndr, "in", "spoolss_64");
28752                 ndr->depth++;
28753                 ndr->depth--;
28754         }
28755         if (flags & NDR_OUT) {
28756                 ndr_print_struct(ndr, "out", "spoolss_64");
28757                 ndr->depth++;
28758                 ndr_print_WERROR(ndr, "result", r->out.result);
28759                 ndr->depth--;
28760         }
28761         ndr->depth--;
28762 }
28763
28764 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
28765 {
28766         if (flags & NDR_IN) {
28767         }
28768         if (flags & NDR_OUT) {
28769                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28770         }
28771         return NDR_ERR_SUCCESS;
28772 }
28773
28774 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
28775 {
28776         if (flags & NDR_IN) {
28777         }
28778         if (flags & NDR_OUT) {
28779                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28780         }
28781         return NDR_ERR_SUCCESS;
28782 }
28783
28784 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
28785 {
28786         ndr_print_struct(ndr, name, "spoolss_65");
28787         ndr->depth++;
28788         if (flags & NDR_SET_VALUES) {
28789                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28790         }
28791         if (flags & NDR_IN) {
28792                 ndr_print_struct(ndr, "in", "spoolss_65");
28793                 ndr->depth++;
28794                 ndr->depth--;
28795         }
28796         if (flags & NDR_OUT) {
28797                 ndr_print_struct(ndr, "out", "spoolss_65");
28798                 ndr->depth++;
28799                 ndr_print_WERROR(ndr, "result", r->out.result);
28800                 ndr->depth--;
28801         }
28802         ndr->depth--;
28803 }
28804
28805 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
28806 {
28807         uint32_t cntr_core_printer_drivers_1;
28808         if (flags & NDR_IN) {
28809                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
28810                 if (r->in.servername) {
28811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28814                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28815                 }
28816                 if (r->in.architecture == NULL) {
28817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28818                 }
28819                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28820                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28821                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28822                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
28824                 if (r->in.core_driver_dependencies == NULL) {
28825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28826                 }
28827                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
28828                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
28829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
28830         }
28831         if (flags & NDR_OUT) {
28832                 if (r->out.core_printer_drivers == NULL) {
28833                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28834                 }
28835                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
28836                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
28837                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
28838                 }
28839                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28840         }
28841         return NDR_ERR_SUCCESS;
28842 }
28843
28844 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
28845 {
28846         uint32_t _ptr_servername;
28847         uint32_t cntr_core_printer_drivers_1;
28848         TALLOC_CTX *_mem_save_servername_0;
28849         TALLOC_CTX *_mem_save_core_printer_drivers_1;
28850         if (flags & NDR_IN) {
28851                 ZERO_STRUCT(r->out);
28852
28853                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
28854                 if (_ptr_servername) {
28855                         NDR_PULL_ALLOC(ndr, r->in.servername);
28856                 } else {
28857                         r->in.servername = NULL;
28858                 }
28859                 if (r->in.servername) {
28860                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
28861                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
28862                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
28863                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
28864                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
28865                                 return 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));
28866                         }
28867                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
28868                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
28869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
28870                 }
28871                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28872                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28873                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28874                         return 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));
28875                 }
28876                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28877                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
28879                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
28880                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.core_driver_dependencies, ndr_get_array_size(ndr, &r->in.core_driver_dependencies), sizeof(uint16_t), CH_UTF16));
28881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
28882                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
28883                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
28884                 if (r->in.core_driver_dependencies) {
28885                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
28886                 }
28887         }
28888         if (flags & NDR_OUT) {
28889                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
28890                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28891                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
28892                 }
28893                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
28894                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
28895                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
28896                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
28897                 }
28898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
28899                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28900                 if (r->out.core_printer_drivers) {
28901                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
28902                 }
28903         }
28904         return NDR_ERR_SUCCESS;
28905 }
28906
28907 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
28908 {
28909         uint32_t cntr_core_printer_drivers_1;
28910         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
28911         ndr->depth++;
28912         if (flags & NDR_SET_VALUES) {
28913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28914         }
28915         if (flags & NDR_IN) {
28916                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
28917                 ndr->depth++;
28918                 ndr_print_ptr(ndr, "servername", r->in.servername);
28919                 ndr->depth++;
28920                 if (r->in.servername) {
28921                         ndr_print_string(ndr, "servername", r->in.servername);
28922                 }
28923                 ndr->depth--;
28924                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
28925                 ndr->depth++;
28926                 ndr_print_string(ndr, "architecture", r->in.architecture);
28927                 ndr->depth--;
28928                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
28929                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
28930                 ndr->depth++;
28931                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
28932                 ndr->depth--;
28933                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
28934                 ndr->depth--;
28935         }
28936         if (flags & NDR_OUT) {
28937                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
28938                 ndr->depth++;
28939                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
28940                 ndr->depth++;
28941                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
28942                 ndr->depth++;
28943                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
28944                         char *idx_1=NULL;
28945                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
28946                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
28947                                 free(idx_1);
28948                         }
28949                 }
28950                 ndr->depth--;
28951                 ndr->depth--;
28952                 ndr_print_WERROR(ndr, "result", r->out.result);
28953                 ndr->depth--;
28954         }
28955         ndr->depth--;
28956 }
28957
28958 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
28959 {
28960         if (flags & NDR_IN) {
28961         }
28962         if (flags & NDR_OUT) {
28963                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28964         }
28965         return NDR_ERR_SUCCESS;
28966 }
28967
28968 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
28969 {
28970         if (flags & NDR_IN) {
28971         }
28972         if (flags & NDR_OUT) {
28973                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28974         }
28975         return NDR_ERR_SUCCESS;
28976 }
28977
28978 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
28979 {
28980         ndr_print_struct(ndr, name, "spoolss_67");
28981         ndr->depth++;
28982         if (flags & NDR_SET_VALUES) {
28983                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28984         }
28985         if (flags & NDR_IN) {
28986                 ndr_print_struct(ndr, "in", "spoolss_67");
28987                 ndr->depth++;
28988                 ndr->depth--;
28989         }
28990         if (flags & NDR_OUT) {
28991                 ndr_print_struct(ndr, "out", "spoolss_67");
28992                 ndr->depth++;
28993                 ndr_print_WERROR(ndr, "result", r->out.result);
28994                 ndr->depth--;
28995         }
28996         ndr->depth--;
28997 }
28998
28999 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29000 {
29001         if (flags & NDR_IN) {
29002                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29003                 if (r->in.servername) {
29004                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29005                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29006                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29007                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29008                 }
29009                 if (r->in.architecture == NULL) {
29010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29011                 }
29012                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29013                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29014                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29015                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29016                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
29017                 if (r->in.language) {
29018                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29019                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29020                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29021                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29022                 }
29023                 if (r->in.package_id == NULL) {
29024                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29025                 }
29026                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29027                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29028                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29029                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.package_id, ndr_charset_length(r->in.package_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
29031                 if (r->in.driver_package_cab) {
29032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29033                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29034                 }
29035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29036         }
29037         if (flags & NDR_OUT) {
29038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
29039                 if (r->out.driver_package_cab) {
29040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29041                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29042                 }
29043                 if (r->out.required == NULL) {
29044                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29045                 }
29046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
29047                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29048         }
29049         return NDR_ERR_SUCCESS;
29050 }
29051
29052 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
29053 {
29054         uint32_t _ptr_servername;
29055         uint32_t _ptr_language;
29056         uint32_t _ptr_driver_package_cab;
29057         TALLOC_CTX *_mem_save_servername_0;
29058         TALLOC_CTX *_mem_save_language_0;
29059         TALLOC_CTX *_mem_save_driver_package_cab_0;
29060         TALLOC_CTX *_mem_save_required_0;
29061         if (flags & NDR_IN) {
29062                 ZERO_STRUCT(r->out);
29063
29064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29065                 if (_ptr_servername) {
29066                         NDR_PULL_ALLOC(ndr, r->in.servername);
29067                 } else {
29068                         r->in.servername = NULL;
29069                 }
29070                 if (r->in.servername) {
29071                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29072                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29073                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29074                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29075                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29076                                 return 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));
29077                         }
29078                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29079                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29081                 }
29082                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29083                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29084                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29085                         return 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));
29086                 }
29087                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29088                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
29090                 if (_ptr_language) {
29091                         NDR_PULL_ALLOC(ndr, r->in.language);
29092                 } else {
29093                         r->in.language = NULL;
29094                 }
29095                 if (r->in.language) {
29096                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
29097                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
29098                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
29099                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
29100                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
29101                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.language), ndr_get_array_length(ndr, &r->in.language));
29102                         }
29103                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
29104                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
29105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
29106                 }
29107                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
29108                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
29109                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
29110                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.package_id), ndr_get_array_length(ndr, &r->in.package_id));
29111                 }
29112                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
29113                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.package_id, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t), CH_UTF16));
29114                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29115                 if (_ptr_driver_package_cab) {
29116                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
29117                 } else {
29118                         r->in.driver_package_cab = NULL;
29119                 }
29120                 if (r->in.driver_package_cab) {
29121                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29122                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
29123                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
29124                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver_package_cab, ndr_get_array_size(ndr, &r->in.driver_package_cab), sizeof(uint16_t), CH_UTF16));
29125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29126                 }
29127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
29128                 NDR_PULL_ALLOC(ndr, r->out.required);
29129                 ZERO_STRUCTP(r->out.required);
29130                 if (r->in.driver_package_cab) {
29131                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
29132                 }
29133         }
29134         if (flags & NDR_OUT) {
29135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29136                 if (_ptr_driver_package_cab) {
29137                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
29138                 } else {
29139                         r->out.driver_package_cab = NULL;
29140                 }
29141                 if (r->out.driver_package_cab) {
29142                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29143                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
29144                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
29145                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.driver_package_cab, ndr_get_array_size(ndr, &r->out.driver_package_cab), sizeof(uint16_t), CH_UTF16));
29146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29147                 }
29148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29149                         NDR_PULL_ALLOC(ndr, r->out.required);
29150                 }
29151                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
29152                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
29153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
29154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
29155                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29156                 if (r->out.driver_package_cab) {
29157                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
29158                 }
29159         }
29160         return NDR_ERR_SUCCESS;
29161 }
29162
29163 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29164 {
29165         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
29166         ndr->depth++;
29167         if (flags & NDR_SET_VALUES) {
29168                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29169         }
29170         if (flags & NDR_IN) {
29171                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
29172                 ndr->depth++;
29173                 ndr_print_ptr(ndr, "servername", r->in.servername);
29174                 ndr->depth++;
29175                 if (r->in.servername) {
29176                         ndr_print_string(ndr, "servername", r->in.servername);
29177                 }
29178                 ndr->depth--;
29179                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29180                 ndr->depth++;
29181                 ndr_print_string(ndr, "architecture", r->in.architecture);
29182                 ndr->depth--;
29183                 ndr_print_ptr(ndr, "language", r->in.language);
29184                 ndr->depth++;
29185                 if (r->in.language) {
29186                         ndr_print_string(ndr, "language", r->in.language);
29187                 }
29188                 ndr->depth--;
29189                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
29190                 ndr->depth++;
29191                 ndr_print_string(ndr, "package_id", r->in.package_id);
29192                 ndr->depth--;
29193                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
29194                 ndr->depth++;
29195                 if (r->in.driver_package_cab) {
29196                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
29197                 }
29198                 ndr->depth--;
29199                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
29200                 ndr->depth--;
29201         }
29202         if (flags & NDR_OUT) {
29203                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
29204                 ndr->depth++;
29205                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
29206                 ndr->depth++;
29207                 if (r->out.driver_package_cab) {
29208                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
29209                 }
29210                 ndr->depth--;
29211                 ndr_print_ptr(ndr, "required", r->out.required);
29212                 ndr->depth++;
29213                 ndr_print_uint32(ndr, "required", *r->out.required);
29214                 ndr->depth--;
29215                 ndr_print_WERROR(ndr, "result", r->out.result);
29216                 ndr->depth--;
29217         }
29218         ndr->depth--;
29219 }
29220
29221 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
29222 {
29223         if (flags & NDR_IN) {
29224         }
29225         if (flags & NDR_OUT) {
29226                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29227         }
29228         return NDR_ERR_SUCCESS;
29229 }
29230
29231 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
29232 {
29233         if (flags & NDR_IN) {
29234         }
29235         if (flags & NDR_OUT) {
29236                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29237         }
29238         return NDR_ERR_SUCCESS;
29239 }
29240
29241 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
29242 {
29243         ndr_print_struct(ndr, name, "spoolss_69");
29244         ndr->depth++;
29245         if (flags & NDR_SET_VALUES) {
29246                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29247         }
29248         if (flags & NDR_IN) {
29249                 ndr_print_struct(ndr, "in", "spoolss_69");
29250                 ndr->depth++;
29251                 ndr->depth--;
29252         }
29253         if (flags & NDR_OUT) {
29254                 ndr_print_struct(ndr, "out", "spoolss_69");
29255                 ndr->depth++;
29256                 ndr_print_WERROR(ndr, "result", r->out.result);
29257                 ndr->depth--;
29258         }
29259         ndr->depth--;
29260 }
29261
29262 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
29263 {
29264         if (flags & NDR_IN) {
29265         }
29266         if (flags & NDR_OUT) {
29267                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29268         }
29269         return NDR_ERR_SUCCESS;
29270 }
29271
29272 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
29273 {
29274         if (flags & NDR_IN) {
29275         }
29276         if (flags & NDR_OUT) {
29277                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29278         }
29279         return NDR_ERR_SUCCESS;
29280 }
29281
29282 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
29283 {
29284         ndr_print_struct(ndr, name, "spoolss_6a");
29285         ndr->depth++;
29286         if (flags & NDR_SET_VALUES) {
29287                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29288         }
29289         if (flags & NDR_IN) {
29290                 ndr_print_struct(ndr, "in", "spoolss_6a");
29291                 ndr->depth++;
29292                 ndr->depth--;
29293         }
29294         if (flags & NDR_OUT) {
29295                 ndr_print_struct(ndr, "out", "spoolss_6a");
29296                 ndr->depth++;
29297                 ndr_print_WERROR(ndr, "result", r->out.result);
29298                 ndr->depth--;
29299         }
29300         ndr->depth--;
29301 }
29302
29303 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
29304 {
29305         if (flags & NDR_IN) {
29306         }
29307         if (flags & NDR_OUT) {
29308                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29309         }
29310         return NDR_ERR_SUCCESS;
29311 }
29312
29313 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
29314 {
29315         if (flags & NDR_IN) {
29316         }
29317         if (flags & NDR_OUT) {
29318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29319         }
29320         return NDR_ERR_SUCCESS;
29321 }
29322
29323 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
29324 {
29325         ndr_print_struct(ndr, name, "spoolss_6b");
29326         ndr->depth++;
29327         if (flags & NDR_SET_VALUES) {
29328                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29329         }
29330         if (flags & NDR_IN) {
29331                 ndr_print_struct(ndr, "in", "spoolss_6b");
29332                 ndr->depth++;
29333                 ndr->depth--;
29334         }
29335         if (flags & NDR_OUT) {
29336                 ndr_print_struct(ndr, "out", "spoolss_6b");
29337                 ndr->depth++;
29338                 ndr_print_WERROR(ndr, "result", r->out.result);
29339                 ndr->depth--;
29340         }
29341         ndr->depth--;
29342 }
29343
29344 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
29345 {
29346         if (flags & NDR_IN) {
29347         }
29348         if (flags & NDR_OUT) {
29349                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29350         }
29351         return NDR_ERR_SUCCESS;
29352 }
29353
29354 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
29355 {
29356         if (flags & NDR_IN) {
29357         }
29358         if (flags & NDR_OUT) {
29359                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29360         }
29361         return NDR_ERR_SUCCESS;
29362 }
29363
29364 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
29365 {
29366         ndr_print_struct(ndr, name, "spoolss_6c");
29367         ndr->depth++;
29368         if (flags & NDR_SET_VALUES) {
29369                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29370         }
29371         if (flags & NDR_IN) {
29372                 ndr_print_struct(ndr, "in", "spoolss_6c");
29373                 ndr->depth++;
29374                 ndr->depth--;
29375         }
29376         if (flags & NDR_OUT) {
29377                 ndr_print_struct(ndr, "out", "spoolss_6c");
29378                 ndr->depth++;
29379                 ndr_print_WERROR(ndr, "result", r->out.result);
29380                 ndr->depth--;
29381         }
29382         ndr->depth--;
29383 }
29384
29385 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
29386 {
29387         if (flags & NDR_IN) {
29388         }
29389         if (flags & NDR_OUT) {
29390                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29391         }
29392         return NDR_ERR_SUCCESS;
29393 }
29394
29395 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
29396 {
29397         if (flags & NDR_IN) {
29398         }
29399         if (flags & NDR_OUT) {
29400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29401         }
29402         return NDR_ERR_SUCCESS;
29403 }
29404
29405 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
29406 {
29407         ndr_print_struct(ndr, name, "spoolss_6d");
29408         ndr->depth++;
29409         if (flags & NDR_SET_VALUES) {
29410                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29411         }
29412         if (flags & NDR_IN) {
29413                 ndr_print_struct(ndr, "in", "spoolss_6d");
29414                 ndr->depth++;
29415                 ndr->depth--;
29416         }
29417         if (flags & NDR_OUT) {
29418                 ndr_print_struct(ndr, "out", "spoolss_6d");
29419                 ndr->depth++;
29420                 ndr_print_WERROR(ndr, "result", r->out.result);
29421                 ndr->depth--;
29422         }
29423         ndr->depth--;
29424 }
29425
29426 static const struct ndr_interface_call spoolss_calls[] = {
29427         {
29428                 "spoolss_EnumPrinters",
29429                 sizeof(struct spoolss_EnumPrinters),
29430                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
29431                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
29432                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
29433                 false,
29434         },
29435         {
29436                 "spoolss_OpenPrinter",
29437                 sizeof(struct spoolss_OpenPrinter),
29438                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
29439                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
29440                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
29441                 false,
29442         },
29443         {
29444                 "spoolss_SetJob",
29445                 sizeof(struct spoolss_SetJob),
29446                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
29447                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
29448                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
29449                 false,
29450         },
29451         {
29452                 "spoolss_GetJob",
29453                 sizeof(struct spoolss_GetJob),
29454                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
29455                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
29456                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
29457                 false,
29458         },
29459         {
29460                 "spoolss_EnumJobs",
29461                 sizeof(struct spoolss_EnumJobs),
29462                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
29463                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
29464                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
29465                 false,
29466         },
29467         {
29468                 "spoolss_AddPrinter",
29469                 sizeof(struct spoolss_AddPrinter),
29470                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
29471                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
29472                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
29473                 false,
29474         },
29475         {
29476                 "spoolss_DeletePrinter",
29477                 sizeof(struct spoolss_DeletePrinter),
29478                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
29479                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
29480                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
29481                 false,
29482         },
29483         {
29484                 "spoolss_SetPrinter",
29485                 sizeof(struct spoolss_SetPrinter),
29486                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
29487                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
29488                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
29489                 false,
29490         },
29491         {
29492                 "spoolss_GetPrinter",
29493                 sizeof(struct spoolss_GetPrinter),
29494                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
29495                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
29496                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
29497                 false,
29498         },
29499         {
29500                 "spoolss_AddPrinterDriver",
29501                 sizeof(struct spoolss_AddPrinterDriver),
29502                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
29503                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
29504                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
29505                 false,
29506         },
29507         {
29508                 "spoolss_EnumPrinterDrivers",
29509                 sizeof(struct spoolss_EnumPrinterDrivers),
29510                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
29511                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
29512                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
29513                 false,
29514         },
29515         {
29516                 "spoolss_GetPrinterDriver",
29517                 sizeof(struct spoolss_GetPrinterDriver),
29518                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
29519                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
29520                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
29521                 false,
29522         },
29523         {
29524                 "spoolss_GetPrinterDriverDirectory",
29525                 sizeof(struct spoolss_GetPrinterDriverDirectory),
29526                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
29527                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
29528                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
29529                 false,
29530         },
29531         {
29532                 "spoolss_DeletePrinterDriver",
29533                 sizeof(struct spoolss_DeletePrinterDriver),
29534                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
29535                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
29536                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
29537                 false,
29538         },
29539         {
29540                 "spoolss_AddPrintProcessor",
29541                 sizeof(struct spoolss_AddPrintProcessor),
29542                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
29543                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
29544                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
29545                 false,
29546         },
29547         {
29548                 "spoolss_EnumPrintProcessors",
29549                 sizeof(struct spoolss_EnumPrintProcessors),
29550                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
29551                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
29552                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
29553                 false,
29554         },
29555         {
29556                 "spoolss_GetPrintProcessorDirectory",
29557                 sizeof(struct spoolss_GetPrintProcessorDirectory),
29558                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
29559                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
29560                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
29561                 false,
29562         },
29563         {
29564                 "spoolss_StartDocPrinter",
29565                 sizeof(struct spoolss_StartDocPrinter),
29566                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
29567                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
29568                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
29569                 false,
29570         },
29571         {
29572                 "spoolss_StartPagePrinter",
29573                 sizeof(struct spoolss_StartPagePrinter),
29574                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
29575                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
29576                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
29577                 false,
29578         },
29579         {
29580                 "spoolss_WritePrinter",
29581                 sizeof(struct spoolss_WritePrinter),
29582                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
29583                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
29584                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
29585                 false,
29586         },
29587         {
29588                 "spoolss_EndPagePrinter",
29589                 sizeof(struct spoolss_EndPagePrinter),
29590                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
29591                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
29592                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
29593                 false,
29594         },
29595         {
29596                 "spoolss_AbortPrinter",
29597                 sizeof(struct spoolss_AbortPrinter),
29598                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
29599                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
29600                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
29601                 false,
29602         },
29603         {
29604                 "spoolss_ReadPrinter",
29605                 sizeof(struct spoolss_ReadPrinter),
29606                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
29607                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
29608                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
29609                 false,
29610         },
29611         {
29612                 "spoolss_EndDocPrinter",
29613                 sizeof(struct spoolss_EndDocPrinter),
29614                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
29615                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
29616                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
29617                 false,
29618         },
29619         {
29620                 "spoolss_AddJob",
29621                 sizeof(struct spoolss_AddJob),
29622                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
29623                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
29624                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
29625                 false,
29626         },
29627         {
29628                 "spoolss_ScheduleJob",
29629                 sizeof(struct spoolss_ScheduleJob),
29630                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
29631                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
29632                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
29633                 false,
29634         },
29635         {
29636                 "spoolss_GetPrinterData",
29637                 sizeof(struct spoolss_GetPrinterData),
29638                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
29639                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
29640                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
29641                 false,
29642         },
29643         {
29644                 "spoolss_SetPrinterData",
29645                 sizeof(struct spoolss_SetPrinterData),
29646                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
29647                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
29648                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
29649                 false,
29650         },
29651         {
29652                 "spoolss_WaitForPrinterChange",
29653                 sizeof(struct spoolss_WaitForPrinterChange),
29654                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
29655                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
29656                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
29657                 false,
29658         },
29659         {
29660                 "spoolss_ClosePrinter",
29661                 sizeof(struct spoolss_ClosePrinter),
29662                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
29663                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
29664                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
29665                 false,
29666         },
29667         {
29668                 "spoolss_AddForm",
29669                 sizeof(struct spoolss_AddForm),
29670                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
29671                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
29672                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
29673                 false,
29674         },
29675         {
29676                 "spoolss_DeleteForm",
29677                 sizeof(struct spoolss_DeleteForm),
29678                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
29679                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
29680                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
29681                 false,
29682         },
29683         {
29684                 "spoolss_GetForm",
29685                 sizeof(struct spoolss_GetForm),
29686                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
29687                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
29688                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
29689                 false,
29690         },
29691         {
29692                 "spoolss_SetForm",
29693                 sizeof(struct spoolss_SetForm),
29694                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
29695                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
29696                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
29697                 false,
29698         },
29699         {
29700                 "spoolss_EnumForms",
29701                 sizeof(struct spoolss_EnumForms),
29702                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
29703                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
29704                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
29705                 false,
29706         },
29707         {
29708                 "spoolss_EnumPorts",
29709                 sizeof(struct spoolss_EnumPorts),
29710                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
29711                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
29712                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
29713                 false,
29714         },
29715         {
29716                 "spoolss_EnumMonitors",
29717                 sizeof(struct spoolss_EnumMonitors),
29718                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
29719                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
29720                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
29721                 false,
29722         },
29723         {
29724                 "spoolss_AddPort",
29725                 sizeof(struct spoolss_AddPort),
29726                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
29727                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
29728                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
29729                 false,
29730         },
29731         {
29732                 "spoolss_ConfigurePort",
29733                 sizeof(struct spoolss_ConfigurePort),
29734                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
29735                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
29736                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
29737                 false,
29738         },
29739         {
29740                 "spoolss_DeletePort",
29741                 sizeof(struct spoolss_DeletePort),
29742                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
29743                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
29744                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
29745                 false,
29746         },
29747         {
29748                 "spoolss_CreatePrinterIC",
29749                 sizeof(struct spoolss_CreatePrinterIC),
29750                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
29751                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
29752                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
29753                 false,
29754         },
29755         {
29756                 "spoolss_PlayGDIScriptOnPrinterIC",
29757                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
29758                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
29759                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
29760                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
29761                 false,
29762         },
29763         {
29764                 "spoolss_DeletePrinterIC",
29765                 sizeof(struct spoolss_DeletePrinterIC),
29766                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
29767                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
29768                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
29769                 false,
29770         },
29771         {
29772                 "spoolss_AddPrinterConnection",
29773                 sizeof(struct spoolss_AddPrinterConnection),
29774                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
29775                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
29776                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
29777                 false,
29778         },
29779         {
29780                 "spoolss_DeletePrinterConnection",
29781                 sizeof(struct spoolss_DeletePrinterConnection),
29782                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
29783                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
29784                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
29785                 false,
29786         },
29787         {
29788                 "spoolss_PrinterMessageBox",
29789                 sizeof(struct spoolss_PrinterMessageBox),
29790                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
29791                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
29792                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
29793                 false,
29794         },
29795         {
29796                 "spoolss_AddMonitor",
29797                 sizeof(struct spoolss_AddMonitor),
29798                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
29799                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
29800                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
29801                 false,
29802         },
29803         {
29804                 "spoolss_DeleteMonitor",
29805                 sizeof(struct spoolss_DeleteMonitor),
29806                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
29807                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
29808                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
29809                 false,
29810         },
29811         {
29812                 "spoolss_DeletePrintProcessor",
29813                 sizeof(struct spoolss_DeletePrintProcessor),
29814                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
29815                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
29816                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
29817                 false,
29818         },
29819         {
29820                 "spoolss_AddPrintProvidor",
29821                 sizeof(struct spoolss_AddPrintProvidor),
29822                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
29823                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
29824                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
29825                 false,
29826         },
29827         {
29828                 "spoolss_DeletePrintProvidor",
29829                 sizeof(struct spoolss_DeletePrintProvidor),
29830                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
29831                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
29832                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
29833                 false,
29834         },
29835         {
29836                 "spoolss_EnumPrintProcDataTypes",
29837                 sizeof(struct spoolss_EnumPrintProcDataTypes),
29838                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
29839                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
29840                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
29841                 false,
29842         },
29843         {
29844                 "spoolss_ResetPrinter",
29845                 sizeof(struct spoolss_ResetPrinter),
29846                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
29847                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
29848                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
29849                 false,
29850         },
29851         {
29852                 "spoolss_GetPrinterDriver2",
29853                 sizeof(struct spoolss_GetPrinterDriver2),
29854                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
29855                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
29856                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
29857                 false,
29858         },
29859         {
29860                 "spoolss_FindFirstPrinterChangeNotification",
29861                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
29862                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
29863                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
29864                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
29865                 false,
29866         },
29867         {
29868                 "spoolss_FindNextPrinterChangeNotification",
29869                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
29870                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
29871                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
29872                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
29873                 false,
29874         },
29875         {
29876                 "spoolss_FindClosePrinterNotify",
29877                 sizeof(struct spoolss_FindClosePrinterNotify),
29878                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
29879                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
29880                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
29881                 false,
29882         },
29883         {
29884                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
29885                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
29886                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
29887                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
29888                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
29889                 false,
29890         },
29891         {
29892                 "spoolss_ReplyOpenPrinter",
29893                 sizeof(struct spoolss_ReplyOpenPrinter),
29894                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
29895                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
29896                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
29897                 false,
29898         },
29899         {
29900                 "spoolss_RouterReplyPrinter",
29901                 sizeof(struct spoolss_RouterReplyPrinter),
29902                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
29903                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
29904                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
29905                 false,
29906         },
29907         {
29908                 "spoolss_ReplyClosePrinter",
29909                 sizeof(struct spoolss_ReplyClosePrinter),
29910                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
29911                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
29912                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
29913                 false,
29914         },
29915         {
29916                 "spoolss_AddPortEx",
29917                 sizeof(struct spoolss_AddPortEx),
29918                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
29919                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
29920                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
29921                 false,
29922         },
29923         {
29924                 "spoolss_RouterFindFirstPrinterChangeNotification",
29925                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
29926                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
29927                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
29928                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
29929                 false,
29930         },
29931         {
29932                 "spoolss_SpoolerInit",
29933                 sizeof(struct spoolss_SpoolerInit),
29934                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
29935                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
29936                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
29937                 false,
29938         },
29939         {
29940                 "spoolss_ResetPrinterEx",
29941                 sizeof(struct spoolss_ResetPrinterEx),
29942                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
29943                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
29944                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
29945                 false,
29946         },
29947         {
29948                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
29949                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
29950                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
29951                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
29952                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
29953                 false,
29954         },
29955         {
29956                 "spoolss_RouterReplyPrinterEx",
29957                 sizeof(struct spoolss_RouterReplyPrinterEx),
29958                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
29959                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
29960                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
29961                 false,
29962         },
29963         {
29964                 "spoolss_RouterRefreshPrinterChangeNotify",
29965                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
29966                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
29967                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
29968                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
29969                 false,
29970         },
29971         {
29972                 "spoolss_44",
29973                 sizeof(struct spoolss_44),
29974                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
29975                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
29976                 (ndr_print_function_t) ndr_print_spoolss_44,
29977                 false,
29978         },
29979         {
29980                 "spoolss_OpenPrinterEx",
29981                 sizeof(struct spoolss_OpenPrinterEx),
29982                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
29983                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
29984                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
29985                 false,
29986         },
29987         {
29988                 "spoolss_AddPrinterEx",
29989                 sizeof(struct spoolss_AddPrinterEx),
29990                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
29991                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
29992                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
29993                 false,
29994         },
29995         {
29996                 "spoolss_47",
29997                 sizeof(struct spoolss_47),
29998                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
29999                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
30000                 (ndr_print_function_t) ndr_print_spoolss_47,
30001                 false,
30002         },
30003         {
30004                 "spoolss_EnumPrinterData",
30005                 sizeof(struct spoolss_EnumPrinterData),
30006                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
30007                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
30008                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
30009                 false,
30010         },
30011         {
30012                 "spoolss_DeletePrinterData",
30013                 sizeof(struct spoolss_DeletePrinterData),
30014                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
30015                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
30016                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
30017                 false,
30018         },
30019         {
30020                 "spoolss_4a",
30021                 sizeof(struct spoolss_4a),
30022                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
30023                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
30024                 (ndr_print_function_t) ndr_print_spoolss_4a,
30025                 false,
30026         },
30027         {
30028                 "spoolss_4b",
30029                 sizeof(struct spoolss_4b),
30030                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
30031                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
30032                 (ndr_print_function_t) ndr_print_spoolss_4b,
30033                 false,
30034         },
30035         {
30036                 "spoolss_4c",
30037                 sizeof(struct spoolss_4c),
30038                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
30039                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
30040                 (ndr_print_function_t) ndr_print_spoolss_4c,
30041                 false,
30042         },
30043         {
30044                 "spoolss_SetPrinterDataEx",
30045                 sizeof(struct spoolss_SetPrinterDataEx),
30046                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
30047                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
30048                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
30049                 false,
30050         },
30051         {
30052                 "spoolss_GetPrinterDataEx",
30053                 sizeof(struct spoolss_GetPrinterDataEx),
30054                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
30055                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
30056                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
30057                 false,
30058         },
30059         {
30060                 "spoolss_EnumPrinterDataEx",
30061                 sizeof(struct spoolss_EnumPrinterDataEx),
30062                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
30063                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
30064                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
30065                 false,
30066         },
30067         {
30068                 "spoolss_EnumPrinterKey",
30069                 sizeof(struct spoolss_EnumPrinterKey),
30070                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
30071                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
30072                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
30073                 false,
30074         },
30075         {
30076                 "spoolss_DeletePrinterDataEx",
30077                 sizeof(struct spoolss_DeletePrinterDataEx),
30078                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
30079                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
30080                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
30081                 false,
30082         },
30083         {
30084                 "spoolss_DeletePrinterKey",
30085                 sizeof(struct spoolss_DeletePrinterKey),
30086                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
30087                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
30088                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
30089                 false,
30090         },
30091         {
30092                 "spoolss_53",
30093                 sizeof(struct spoolss_53),
30094                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
30095                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
30096                 (ndr_print_function_t) ndr_print_spoolss_53,
30097                 false,
30098         },
30099         {
30100                 "spoolss_DeletePrinterDriverEx",
30101                 sizeof(struct spoolss_DeletePrinterDriverEx),
30102                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
30103                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
30104                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
30105                 false,
30106         },
30107         {
30108                 "spoolss_55",
30109                 sizeof(struct spoolss_55),
30110                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
30111                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
30112                 (ndr_print_function_t) ndr_print_spoolss_55,
30113                 false,
30114         },
30115         {
30116                 "spoolss_56",
30117                 sizeof(struct spoolss_56),
30118                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
30119                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
30120                 (ndr_print_function_t) ndr_print_spoolss_56,
30121                 false,
30122         },
30123         {
30124                 "spoolss_57",
30125                 sizeof(struct spoolss_57),
30126                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
30127                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
30128                 (ndr_print_function_t) ndr_print_spoolss_57,
30129                 false,
30130         },
30131         {
30132                 "spoolss_XcvData",
30133                 sizeof(struct spoolss_XcvData),
30134                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
30135                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
30136                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
30137                 false,
30138         },
30139         {
30140                 "spoolss_AddPrinterDriverEx",
30141                 sizeof(struct spoolss_AddPrinterDriverEx),
30142                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
30143                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
30144                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
30145                 false,
30146         },
30147         {
30148                 "spoolss_5a",
30149                 sizeof(struct spoolss_5a),
30150                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
30151                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
30152                 (ndr_print_function_t) ndr_print_spoolss_5a,
30153                 false,
30154         },
30155         {
30156                 "spoolss_5b",
30157                 sizeof(struct spoolss_5b),
30158                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
30159                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
30160                 (ndr_print_function_t) ndr_print_spoolss_5b,
30161                 false,
30162         },
30163         {
30164                 "spoolss_5c",
30165                 sizeof(struct spoolss_5c),
30166                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
30167                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
30168                 (ndr_print_function_t) ndr_print_spoolss_5c,
30169                 false,
30170         },
30171         {
30172                 "spoolss_5d",
30173                 sizeof(struct spoolss_5d),
30174                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
30175                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
30176                 (ndr_print_function_t) ndr_print_spoolss_5d,
30177                 false,
30178         },
30179         {
30180                 "spoolss_5e",
30181                 sizeof(struct spoolss_5e),
30182                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
30183                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
30184                 (ndr_print_function_t) ndr_print_spoolss_5e,
30185                 false,
30186         },
30187         {
30188                 "spoolss_5f",
30189                 sizeof(struct spoolss_5f),
30190                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
30191                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
30192                 (ndr_print_function_t) ndr_print_spoolss_5f,
30193                 false,
30194         },
30195         {
30196                 "spoolss_60",
30197                 sizeof(struct spoolss_60),
30198                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
30199                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
30200                 (ndr_print_function_t) ndr_print_spoolss_60,
30201                 false,
30202         },
30203         {
30204                 "spoolss_61",
30205                 sizeof(struct spoolss_61),
30206                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
30207                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
30208                 (ndr_print_function_t) ndr_print_spoolss_61,
30209                 false,
30210         },
30211         {
30212                 "spoolss_62",
30213                 sizeof(struct spoolss_62),
30214                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
30215                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
30216                 (ndr_print_function_t) ndr_print_spoolss_62,
30217                 false,
30218         },
30219         {
30220                 "spoolss_63",
30221                 sizeof(struct spoolss_63),
30222                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
30223                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
30224                 (ndr_print_function_t) ndr_print_spoolss_63,
30225                 false,
30226         },
30227         {
30228                 "spoolss_64",
30229                 sizeof(struct spoolss_64),
30230                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
30231                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
30232                 (ndr_print_function_t) ndr_print_spoolss_64,
30233                 false,
30234         },
30235         {
30236                 "spoolss_65",
30237                 sizeof(struct spoolss_65),
30238                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
30239                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
30240                 (ndr_print_function_t) ndr_print_spoolss_65,
30241                 false,
30242         },
30243         {
30244                 "spoolss_GetCorePrinterDrivers",
30245                 sizeof(struct spoolss_GetCorePrinterDrivers),
30246                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
30247                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
30248                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
30249                 false,
30250         },
30251         {
30252                 "spoolss_67",
30253                 sizeof(struct spoolss_67),
30254                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
30255                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
30256                 (ndr_print_function_t) ndr_print_spoolss_67,
30257                 false,
30258         },
30259         {
30260                 "spoolss_GetPrinterDriverPackagePath",
30261                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
30262                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
30263                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
30264                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
30265                 false,
30266         },
30267         {
30268                 "spoolss_69",
30269                 sizeof(struct spoolss_69),
30270                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
30271                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
30272                 (ndr_print_function_t) ndr_print_spoolss_69,
30273                 false,
30274         },
30275         {
30276                 "spoolss_6a",
30277                 sizeof(struct spoolss_6a),
30278                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
30279                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
30280                 (ndr_print_function_t) ndr_print_spoolss_6a,
30281                 false,
30282         },
30283         {
30284                 "spoolss_6b",
30285                 sizeof(struct spoolss_6b),
30286                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
30287                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
30288                 (ndr_print_function_t) ndr_print_spoolss_6b,
30289                 false,
30290         },
30291         {
30292                 "spoolss_6c",
30293                 sizeof(struct spoolss_6c),
30294                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
30295                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
30296                 (ndr_print_function_t) ndr_print_spoolss_6c,
30297                 false,
30298         },
30299         {
30300                 "spoolss_6d",
30301                 sizeof(struct spoolss_6d),
30302                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
30303                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
30304                 (ndr_print_function_t) ndr_print_spoolss_6d,
30305                 false,
30306         },
30307         { NULL, 0, NULL, NULL, NULL, false }
30308 };
30309
30310 static const char * const spoolss_endpoint_strings[] = {
30311         "ncacn_np:[\\pipe\\spoolss]",
30312 };
30313
30314 static const struct ndr_interface_string_array spoolss_endpoints = {
30315         .count  = 1,
30316         .names  = spoolss_endpoint_strings
30317 };
30318
30319 static const char * const spoolss_authservice_strings[] = {
30320         "host",
30321 };
30322
30323 static const struct ndr_interface_string_array spoolss_authservices = {
30324         .count  = 1,
30325         .names  = spoolss_authservice_strings
30326 };
30327
30328
30329 const struct ndr_interface_table ndr_table_spoolss = {
30330         .name           = "spoolss",
30331         .syntax_id      = {
30332                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
30333                 NDR_SPOOLSS_VERSION
30334         },
30335         .helpstring     = NDR_SPOOLSS_HELPSTRING,
30336         .num_calls      = 110,
30337         .calls          = spoolss_calls,
30338         .endpoints      = &spoolss_endpoints,
30339         .authservices   = &spoolss_authservices
30340 };
30341