librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 4));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 516 {
 517         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 518 }
 519
 520 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 521 {
 522         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 527 {
 528         uint32_t v;
 529         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 530         *r = v;
 531         return NDR_ERR_SUCCESS;
 532 }
 533
 534 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 535 {
 536         ndr_print_uint32(ndr, name, r);
 537         ndr->depth++;
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 566         ndr->depth--;
 567 }
 568
 569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 570 {
 571         if (ndr_flags & NDR_SCALARS) {
 572                 NDR_CHECK(ndr_push_align(ndr, 4));
 573                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 578                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 587                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 589                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 590                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 591                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 592                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 593                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 607                 {
 608                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 610                         {
 611                                 struct ndr_push *_ndr_driverextra_data;
 612                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 613                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 614                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 615                         }
 616                         ndr->flags = _flags_save_DATA_BLOB;
 617                 }
 618         }
 619         if (ndr_flags & NDR_BUFFERS) {
 620         }
 621         return NDR_ERR_SUCCESS;
 622 }
 623
 624 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 625 {
 626         if (ndr_flags & NDR_SCALARS) {
 627                 NDR_CHECK(ndr_pull_align(ndr, 4));
 628                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 633                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 642                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 644                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 645                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 646                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 647                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 648                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 662                 {
 663                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 665                         {
 666                                 struct ndr_pull *_ndr_driverextra_data;
 667                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 668                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 669                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 670                         }
 671                         ndr->flags = _flags_save_DATA_BLOB;
 672                 }
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675         }
 676         return NDR_ERR_SUCCESS;
 677 }
 678
 679 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 680 {
 681         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 682         ndr->depth++;
 683         ndr_print_string(ndr, "devicename", r->devicename);
 684         ndr_print_uint16(ndr, "specversion", r->specversion);
 685         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 686         ndr_print_uint16(ndr, "size", r->size);
 687         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 688         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 689         ndr_print_uint16(ndr, "orientation", r->orientation);
 690         ndr_print_uint16(ndr, "papersize", r->papersize);
 691         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 692         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 693         ndr_print_uint16(ndr, "scale", r->scale);
 694         ndr_print_uint16(ndr, "copies", r->copies);
 695         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 696         ndr_print_uint16(ndr, "printquality", r->printquality);
 697         ndr_print_uint16(ndr, "color", r->color);
 698         ndr_print_uint16(ndr, "duplex", r->duplex);
 699         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 700         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 701         ndr_print_uint16(ndr, "collate", r->collate);
 702         ndr_print_string(ndr, "formname", r->formname);
 703         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 704         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 705         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 706         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 707         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 708         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 709         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 710         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 711         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 712         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 713         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 714         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 715         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 716         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 717         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 718         ndr->depth--;
 719 }
 720
 721 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 722 {
 723         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 724 }
 725
 726 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 727 {
 728         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 729         return NDR_ERR_SUCCESS;
 730 }
 731
 732 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 733 {
 734         uint32_t v;
 735         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 736         *r = v;
 737         return NDR_ERR_SUCCESS;
 738 }
 739
 740 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 741 {
 742         ndr_print_uint32(ndr, name, r);
 743         ndr->depth++;
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 759         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 763         ndr->depth--;
 764 }
 765
 766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_push_align(ndr, 4));
 770                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 771                 {
 772                         uint32_t _flags_save_string = ndr->flags;
 773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 774                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 775                         ndr->flags = _flags_save_string;
 776                 }
 777                 {
 778                         uint32_t _flags_save_string = ndr->flags;
 779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 780                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 781                         ndr->flags = _flags_save_string;
 782                 }
 783                 {
 784                         uint32_t _flags_save_string = ndr->flags;
 785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 786                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 787                         ndr->flags = _flags_save_string;
 788                 }
 789         }
 790         if (ndr_flags & NDR_BUFFERS) {
 791                 {
 792                         uint32_t _flags_save_string = ndr->flags;
 793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 794                         if (r->name) {
 795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 797                         }
 798                         ndr->flags = _flags_save_string;
 799                 }
 800                 {
 801                         uint32_t _flags_save_string = ndr->flags;
 802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 803                         if (r->description) {
 804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 806                         }
 807                         ndr->flags = _flags_save_string;
 808                 }
 809                 {
 810                         uint32_t _flags_save_string = ndr->flags;
 811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 812                         if (r->comment) {
 813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 814                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 815                         }
 816                         ndr->flags = _flags_save_string;
 817                 }
 818         }
 819         return NDR_ERR_SUCCESS;
 820 }
 821
 822 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 823 {
 824         uint32_t _ptr_name;
 825         TALLOC_CTX *_mem_save_name_0;
 826         uint32_t _ptr_description;
 827         TALLOC_CTX *_mem_save_description_0;
 828         uint32_t _ptr_comment;
 829         TALLOC_CTX *_mem_save_comment_0;
 830         if (ndr_flags & NDR_SCALARS) {
 831                 NDR_CHECK(ndr_pull_align(ndr, 4));
 832                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 833                 {
 834                         uint32_t _flags_save_string = ndr->flags;
 835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 837                         if (_ptr_name) {
 838                                 NDR_PULL_ALLOC(ndr, r->name);
 839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 840                         } else {
 841                                 r->name = NULL;
 842                         }
 843                         ndr->flags = _flags_save_string;
 844                 }
 845                 {
 846                         uint32_t _flags_save_string = ndr->flags;
 847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 849                         if (_ptr_description) {
 850                                 NDR_PULL_ALLOC(ndr, r->description);
 851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 852                         } else {
 853                                 r->description = NULL;
 854                         }
 855                         ndr->flags = _flags_save_string;
 856                 }
 857                 {
 858                         uint32_t _flags_save_string = ndr->flags;
 859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 861                         if (_ptr_comment) {
 862                                 NDR_PULL_ALLOC(ndr, r->comment);
 863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 864                         } else {
 865                                 r->comment = NULL;
 866                         }
 867                         ndr->flags = _flags_save_string;
 868                 }
 869         }
 870         if (ndr_flags & NDR_BUFFERS) {
 871                 {
 872                         uint32_t _flags_save_string = ndr->flags;
 873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 874                         if (r->name) {
 875                                 uint32_t _relative_save_offset;
 876                                 _relative_save_offset = ndr->offset;
 877                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 878                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 879                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 880                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 881                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 882                                 ndr->offset = _relative_save_offset;
 883                         }
 884                         ndr->flags = _flags_save_string;
 885                 }
 886                 {
 887                         uint32_t _flags_save_string = ndr->flags;
 888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 889                         if (r->description) {
 890                                 uint32_t _relative_save_offset;
 891                                 _relative_save_offset = ndr->offset;
 892                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 893                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 894                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 895                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 896                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 897                                 ndr->offset = _relative_save_offset;
 898                         }
 899                         ndr->flags = _flags_save_string;
 900                 }
 901                 {
 902                         uint32_t _flags_save_string = ndr->flags;
 903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 904                         if (r->comment) {
 905                                 uint32_t _relative_save_offset;
 906                                 _relative_save_offset = ndr->offset;
 907                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 908                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 909                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 910                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 911                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 912                                 ndr->offset = _relative_save_offset;
 913                         }
 914                         ndr->flags = _flags_save_string;
 915                 }
 916         }
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 921 {
 922         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 923         ndr->depth++;
 924         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 925         ndr_print_ptr(ndr, "name", r->name);
 926         ndr->depth++;
 927         if (r->name) {
 928                 ndr_print_string(ndr, "name", r->name);
 929         }
 930         ndr->depth--;
 931         ndr_print_ptr(ndr, "description", r->description);
 932         ndr->depth++;
 933         if (r->description) {
 934                 ndr_print_string(ndr, "description", r->description);
 935         }
 936         ndr->depth--;
 937         ndr_print_ptr(ndr, "comment", r->comment);
 938         ndr->depth++;
 939         if (r->comment) {
 940                 ndr_print_string(ndr, "comment", r->comment);
 941         }
 942         ndr->depth--;
 943         ndr->depth--;
 944 }
 945
 946 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
 947 {
 948         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
 949 }
 950
 951 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 952 {
 953         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 958 {
 959         uint32_t v;
 960         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 961         *r = v;
 962         return NDR_ERR_SUCCESS;
 963 }
 964
 965 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 966 {
 967         ndr_print_uint32(ndr, name, r);
 968         ndr->depth++;
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 985         ndr->depth--;
 986 }
 987
 988 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 989 {
 990         if (ndr_flags & NDR_SCALARS) {
 991                 NDR_CHECK(ndr_push_align(ndr, 4));
 992                 {
 993                         uint32_t _flags_save_string = ndr->flags;
 994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 996                         ndr->flags = _flags_save_string;
 997                 }
 998                 {
 999                         uint32_t _flags_save_string = ndr->flags;
1000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1002                         ndr->flags = _flags_save_string;
1003                 }
1004                 {
1005                         uint32_t _flags_save_string = ndr->flags;
1006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1008                         ndr->flags = _flags_save_string;
1009                 }
1010                 {
1011                         uint32_t _flags_save_string = ndr->flags;
1012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1014                         ndr->flags = _flags_save_string;
1015                 }
1016                 {
1017                         uint32_t _flags_save_string = ndr->flags;
1018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1020                         ndr->flags = _flags_save_string;
1021                 }
1022                 {
1023                         uint32_t _flags_save_string = ndr->flags;
1024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1026                         ndr->flags = _flags_save_string;
1027                 }
1028                 {
1029                         uint32_t _flags_save_string = ndr->flags;
1030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1031                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1032                         ndr->flags = _flags_save_string;
1033                 }
1034                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1039                         ndr->flags = _flags_save_string;
1040                 }
1041                 {
1042                         uint32_t _flags_save_string = ndr->flags;
1043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1045                         ndr->flags = _flags_save_string;
1046                 }
1047                 {
1048                         uint32_t _flags_save_string = ndr->flags;
1049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1057                         ndr->flags = _flags_save_string;
1058                 }
1059                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1060                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1065                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1068         }
1069         if (ndr_flags & NDR_BUFFERS) {
1070                 {
1071                         uint32_t _flags_save_string = ndr->flags;
1072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1073                         if (r->servername) {
1074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1076                         }
1077                         ndr->flags = _flags_save_string;
1078                 }
1079                 {
1080                         uint32_t _flags_save_string = ndr->flags;
1081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1082                         if (r->printername) {
1083                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1085                         }
1086                         ndr->flags = _flags_save_string;
1087                 }
1088                 {
1089                         uint32_t _flags_save_string = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1091                         if (r->sharename) {
1092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1094                         }
1095                         ndr->flags = _flags_save_string;
1096                 }
1097                 {
1098                         uint32_t _flags_save_string = ndr->flags;
1099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1100                         if (r->portname) {
1101                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1103                         }
1104                         ndr->flags = _flags_save_string;
1105                 }
1106                 {
1107                         uint32_t _flags_save_string = ndr->flags;
1108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1109                         if (r->drivername) {
1110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1112                         }
1113                         ndr->flags = _flags_save_string;
1114                 }
1115                 {
1116                         uint32_t _flags_save_string = ndr->flags;
1117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1118                         if (r->comment) {
1119                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1120                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1121                         }
1122                         ndr->flags = _flags_save_string;
1123                 }
1124                 {
1125                         uint32_t _flags_save_string = ndr->flags;
1126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1127                         if (r->location) {
1128                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1129                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1130                         }
1131                         ndr->flags = _flags_save_string;
1132                 }
1133                 if (r->devmode) {
1134                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1135                         {
1136                                 struct ndr_push *_ndr_devmode;
1137                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1138                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1139                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1140                         }
1141                 }
1142                 {
1143                         uint32_t _flags_save_string = ndr->flags;
1144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1145                         if (r->sepfile) {
1146                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1147                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1148                         }
1149                         ndr->flags = _flags_save_string;
1150                 }
1151                 {
1152                         uint32_t _flags_save_string = ndr->flags;
1153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1154                         if (r->printprocessor) {
1155                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1156                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1157                         }
1158                         ndr->flags = _flags_save_string;
1159                 }
1160                 {
1161                         uint32_t _flags_save_string = ndr->flags;
1162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1163                         if (r->datatype) {
1164                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1165                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1166                         }
1167                         ndr->flags = _flags_save_string;
1168                 }
1169                 {
1170                         uint32_t _flags_save_string = ndr->flags;
1171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1172                         if (r->parameters) {
1173                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1174                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1175                         }
1176                         ndr->flags = _flags_save_string;
1177                 }
1178                 if (r->secdesc) {
1179                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1180                         {
1181                                 struct ndr_push *_ndr_secdesc;
1182                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1183                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1184                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1185                         }
1186                 }
1187         }
1188         return NDR_ERR_SUCCESS;
1189 }
1190
1191 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1192 {
1193         uint32_t _ptr_servername;
1194         TALLOC_CTX *_mem_save_servername_0;
1195         uint32_t _ptr_printername;
1196         TALLOC_CTX *_mem_save_printername_0;
1197         uint32_t _ptr_sharename;
1198         TALLOC_CTX *_mem_save_sharename_0;
1199         uint32_t _ptr_portname;
1200         TALLOC_CTX *_mem_save_portname_0;
1201         uint32_t _ptr_drivername;
1202         TALLOC_CTX *_mem_save_drivername_0;
1203         uint32_t _ptr_comment;
1204         TALLOC_CTX *_mem_save_comment_0;
1205         uint32_t _ptr_location;
1206         TALLOC_CTX *_mem_save_location_0;
1207         uint32_t _ptr_devmode;
1208         TALLOC_CTX *_mem_save_devmode_0;
1209         uint32_t _ptr_sepfile;
1210         TALLOC_CTX *_mem_save_sepfile_0;
1211         uint32_t _ptr_printprocessor;
1212         TALLOC_CTX *_mem_save_printprocessor_0;
1213         uint32_t _ptr_datatype;
1214         TALLOC_CTX *_mem_save_datatype_0;
1215         uint32_t _ptr_parameters;
1216         TALLOC_CTX *_mem_save_parameters_0;
1217         uint32_t _ptr_secdesc;
1218         TALLOC_CTX *_mem_save_secdesc_0;
1219         if (ndr_flags & NDR_SCALARS) {
1220                 NDR_CHECK(ndr_pull_align(ndr, 4));
1221                 {
1222                         uint32_t _flags_save_string = ndr->flags;
1223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1225                         if (_ptr_servername) {
1226                                 NDR_PULL_ALLOC(ndr, r->servername);
1227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1228                         } else {
1229                                 r->servername = NULL;
1230                         }
1231                         ndr->flags = _flags_save_string;
1232                 }
1233                 {
1234                         uint32_t _flags_save_string = ndr->flags;
1235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1237                         if (_ptr_printername) {
1238                                 NDR_PULL_ALLOC(ndr, r->printername);
1239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1240                         } else {
1241                                 r->printername = NULL;
1242                         }
1243                         ndr->flags = _flags_save_string;
1244                 }
1245                 {
1246                         uint32_t _flags_save_string = ndr->flags;
1247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1248                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1249                         if (_ptr_sharename) {
1250                                 NDR_PULL_ALLOC(ndr, r->sharename);
1251                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1252                         } else {
1253                                 r->sharename = NULL;
1254                         }
1255                         ndr->flags = _flags_save_string;
1256                 }
1257                 {
1258                         uint32_t _flags_save_string = ndr->flags;
1259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1260                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1261                         if (_ptr_portname) {
1262                                 NDR_PULL_ALLOC(ndr, r->portname);
1263                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1264                         } else {
1265                                 r->portname = NULL;
1266                         }
1267                         ndr->flags = _flags_save_string;
1268                 }
1269                 {
1270                         uint32_t _flags_save_string = ndr->flags;
1271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1273                         if (_ptr_drivername) {
1274                                 NDR_PULL_ALLOC(ndr, r->drivername);
1275                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1276                         } else {
1277                                 r->drivername = NULL;
1278                         }
1279                         ndr->flags = _flags_save_string;
1280                 }
1281                 {
1282                         uint32_t _flags_save_string = ndr->flags;
1283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1284                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1285                         if (_ptr_comment) {
1286                                 NDR_PULL_ALLOC(ndr, r->comment);
1287                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1288                         } else {
1289                                 r->comment = NULL;
1290                         }
1291                         ndr->flags = _flags_save_string;
1292                 }
1293                 {
1294                         uint32_t _flags_save_string = ndr->flags;
1295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1296                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1297                         if (_ptr_location) {
1298                                 NDR_PULL_ALLOC(ndr, r->location);
1299                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1300                         } else {
1301                                 r->location = NULL;
1302                         }
1303                         ndr->flags = _flags_save_string;
1304                 }
1305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1306                 if (_ptr_devmode) {
1307                         NDR_PULL_ALLOC(ndr, r->devmode);
1308                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1309                 } else {
1310                         r->devmode = NULL;
1311                 }
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1316                         if (_ptr_sepfile) {
1317                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1319                         } else {
1320                                 r->sepfile = NULL;
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324                 {
1325                         uint32_t _flags_save_string = ndr->flags;
1326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1327                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1328                         if (_ptr_printprocessor) {
1329                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1330                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1331                         } else {
1332                                 r->printprocessor = NULL;
1333                         }
1334                         ndr->flags = _flags_save_string;
1335                 }
1336                 {
1337                         uint32_t _flags_save_string = ndr->flags;
1338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1339                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1340                         if (_ptr_datatype) {
1341                                 NDR_PULL_ALLOC(ndr, r->datatype);
1342                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1343                         } else {
1344                                 r->datatype = NULL;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1352                         if (_ptr_parameters) {
1353                                 NDR_PULL_ALLOC(ndr, r->parameters);
1354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1355                         } else {
1356                                 r->parameters = NULL;
1357                         }
1358                         ndr->flags = _flags_save_string;
1359                 }
1360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1361                 if (_ptr_secdesc) {
1362                         NDR_PULL_ALLOC(ndr, r->secdesc);
1363                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1364                 } else {
1365                         r->secdesc = NULL;
1366                 }
1367                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1369                 if (r->priority > 99) {
1370                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1371                 }
1372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1375                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1378         }
1379         if (ndr_flags & NDR_BUFFERS) {
1380                 {
1381                         uint32_t _flags_save_string = ndr->flags;
1382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1383                         if (r->servername) {
1384                                 uint32_t _relative_save_offset;
1385                                 _relative_save_offset = ndr->offset;
1386                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1387                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1388                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1389                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1390                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1391                                 ndr->offset = _relative_save_offset;
1392                         }
1393                         ndr->flags = _flags_save_string;
1394                 }
1395                 {
1396                         uint32_t _flags_save_string = ndr->flags;
1397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1398                         if (r->printername) {
1399                                 uint32_t _relative_save_offset;
1400                                 _relative_save_offset = ndr->offset;
1401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1402                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1403                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1404                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1406                                 ndr->offset = _relative_save_offset;
1407                         }
1408                         ndr->flags = _flags_save_string;
1409                 }
1410                 {
1411                         uint32_t _flags_save_string = ndr->flags;
1412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1413                         if (r->sharename) {
1414                                 uint32_t _relative_save_offset;
1415                                 _relative_save_offset = ndr->offset;
1416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1417                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1418                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1421                                 ndr->offset = _relative_save_offset;
1422                         }
1423                         ndr->flags = _flags_save_string;
1424                 }
1425                 {
1426                         uint32_t _flags_save_string = ndr->flags;
1427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1428                         if (r->portname) {
1429                                 uint32_t _relative_save_offset;
1430                                 _relative_save_offset = ndr->offset;
1431                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1432                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1433                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1434                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1435                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1436                                 ndr->offset = _relative_save_offset;
1437                         }
1438                         ndr->flags = _flags_save_string;
1439                 }
1440                 {
1441                         uint32_t _flags_save_string = ndr->flags;
1442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1443                         if (r->drivername) {
1444                                 uint32_t _relative_save_offset;
1445                                 _relative_save_offset = ndr->offset;
1446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1447                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1448                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1451                                 ndr->offset = _relative_save_offset;
1452                         }
1453                         ndr->flags = _flags_save_string;
1454                 }
1455                 {
1456                         uint32_t _flags_save_string = ndr->flags;
1457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1458                         if (r->comment) {
1459                                 uint32_t _relative_save_offset;
1460                                 _relative_save_offset = ndr->offset;
1461                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1462                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1463                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1464                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1465                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1466                                 ndr->offset = _relative_save_offset;
1467                         }
1468                         ndr->flags = _flags_save_string;
1469                 }
1470                 {
1471                         uint32_t _flags_save_string = ndr->flags;
1472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1473                         if (r->location) {
1474                                 uint32_t _relative_save_offset;
1475                                 _relative_save_offset = ndr->offset;
1476                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1477                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1478                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1479                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1480                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1481                                 ndr->offset = _relative_save_offset;
1482                         }
1483                         ndr->flags = _flags_save_string;
1484                 }
1485                 if (r->devmode) {
1486                         uint32_t _relative_save_offset;
1487                         _relative_save_offset = ndr->offset;
1488                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1489                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1490                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1491                         {
1492                                 struct ndr_pull *_ndr_devmode;
1493                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1494                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1495                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1496                         }
1497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1498                         ndr->offset = _relative_save_offset;
1499                 }
1500                 {
1501                         uint32_t _flags_save_string = ndr->flags;
1502                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1503                         if (r->sepfile) {
1504                                 uint32_t _relative_save_offset;
1505                                 _relative_save_offset = ndr->offset;
1506                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1507                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1508                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1509                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1510                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1511                                 ndr->offset = _relative_save_offset;
1512                         }
1513                         ndr->flags = _flags_save_string;
1514                 }
1515                 {
1516                         uint32_t _flags_save_string = ndr->flags;
1517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1518                         if (r->printprocessor) {
1519                                 uint32_t _relative_save_offset;
1520                                 _relative_save_offset = ndr->offset;
1521                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1522                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1523                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1524                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1525                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1526                                 ndr->offset = _relative_save_offset;
1527                         }
1528                         ndr->flags = _flags_save_string;
1529                 }
1530                 {
1531                         uint32_t _flags_save_string = ndr->flags;
1532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1533                         if (r->datatype) {
1534                                 uint32_t _relative_save_offset;
1535                                 _relative_save_offset = ndr->offset;
1536                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1537                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1538                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1539                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1540                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1541                                 ndr->offset = _relative_save_offset;
1542                         }
1543                         ndr->flags = _flags_save_string;
1544                 }
1545                 {
1546                         uint32_t _flags_save_string = ndr->flags;
1547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1548                         if (r->parameters) {
1549                                 uint32_t _relative_save_offset;
1550                                 _relative_save_offset = ndr->offset;
1551                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1552                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1553                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1554                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1555                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1556                                 ndr->offset = _relative_save_offset;
1557                         }
1558                         ndr->flags = _flags_save_string;
1559                 }
1560                 if (r->secdesc) {
1561                         uint32_t _relative_save_offset;
1562                         _relative_save_offset = ndr->offset;
1563                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1564                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1565                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1566                         {
1567                                 struct ndr_pull *_ndr_secdesc;
1568                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1569                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1570                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1571                         }
1572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1573                         ndr->offset = _relative_save_offset;
1574                 }
1575         }
1576         return NDR_ERR_SUCCESS;
1577 }
1578
1579 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1580 {
1581         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1582         ndr->depth++;
1583         ndr_print_ptr(ndr, "servername", r->servername);
1584         ndr->depth++;
1585         if (r->servername) {
1586                 ndr_print_string(ndr, "servername", r->servername);
1587         }
1588         ndr->depth--;
1589         ndr_print_ptr(ndr, "printername", r->printername);
1590         ndr->depth++;
1591         if (r->printername) {
1592                 ndr_print_string(ndr, "printername", r->printername);
1593         }
1594         ndr->depth--;
1595         ndr_print_ptr(ndr, "sharename", r->sharename);
1596         ndr->depth++;
1597         if (r->sharename) {
1598                 ndr_print_string(ndr, "sharename", r->sharename);
1599         }
1600         ndr->depth--;
1601         ndr_print_ptr(ndr, "portname", r->portname);
1602         ndr->depth++;
1603         if (r->portname) {
1604                 ndr_print_string(ndr, "portname", r->portname);
1605         }
1606         ndr->depth--;
1607         ndr_print_ptr(ndr, "drivername", r->drivername);
1608         ndr->depth++;
1609         if (r->drivername) {
1610                 ndr_print_string(ndr, "drivername", r->drivername);
1611         }
1612         ndr->depth--;
1613         ndr_print_ptr(ndr, "comment", r->comment);
1614         ndr->depth++;
1615         if (r->comment) {
1616                 ndr_print_string(ndr, "comment", r->comment);
1617         }
1618         ndr->depth--;
1619         ndr_print_ptr(ndr, "location", r->location);
1620         ndr->depth++;
1621         if (r->location) {
1622                 ndr_print_string(ndr, "location", r->location);
1623         }
1624         ndr->depth--;
1625         ndr_print_ptr(ndr, "devmode", r->devmode);
1626         ndr->depth++;
1627         if (r->devmode) {
1628                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1629         }
1630         ndr->depth--;
1631         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1632         ndr->depth++;
1633         if (r->sepfile) {
1634                 ndr_print_string(ndr, "sepfile", r->sepfile);
1635         }
1636         ndr->depth--;
1637         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1638         ndr->depth++;
1639         if (r->printprocessor) {
1640                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1641         }
1642         ndr->depth--;
1643         ndr_print_ptr(ndr, "datatype", r->datatype);
1644         ndr->depth++;
1645         if (r->datatype) {
1646                 ndr_print_string(ndr, "datatype", r->datatype);
1647         }
1648         ndr->depth--;
1649         ndr_print_ptr(ndr, "parameters", r->parameters);
1650         ndr->depth++;
1651         if (r->parameters) {
1652                 ndr_print_string(ndr, "parameters", r->parameters);
1653         }
1654         ndr->depth--;
1655         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1656         ndr->depth++;
1657         if (r->secdesc) {
1658                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1659         }
1660         ndr->depth--;
1661         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1662         ndr_print_uint32(ndr, "priority", r->priority);
1663         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1664         ndr_print_uint32(ndr, "starttime", r->starttime);
1665         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1666         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1667         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1668         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1669         ndr->depth--;
1670 }
1671
1672 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
1673 {
1674         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
1675 }
1676
1677 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1678 {
1679         if (ndr_flags & NDR_SCALARS) {
1680                 NDR_CHECK(ndr_push_align(ndr, 4));
1681                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1682         }
1683         if (ndr_flags & NDR_BUFFERS) {
1684                 if (r->secdesc) {
1685                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1686                         {
1687                                 struct ndr_push *_ndr_secdesc;
1688                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1689                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1690                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1691                         }
1692                 }
1693         }
1694         return NDR_ERR_SUCCESS;
1695 }
1696
1697 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1698 {
1699         uint32_t _ptr_secdesc;
1700         TALLOC_CTX *_mem_save_secdesc_0;
1701         if (ndr_flags & NDR_SCALARS) {
1702                 NDR_CHECK(ndr_pull_align(ndr, 4));
1703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1704                 if (_ptr_secdesc) {
1705                         NDR_PULL_ALLOC(ndr, r->secdesc);
1706                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1707                 } else {
1708                         r->secdesc = NULL;
1709                 }
1710         }
1711         if (ndr_flags & NDR_BUFFERS) {
1712                 if (r->secdesc) {
1713                         uint32_t _relative_save_offset;
1714                         _relative_save_offset = ndr->offset;
1715                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1716                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1717                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1718                         {
1719                                 struct ndr_pull *_ndr_secdesc;
1720                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1721                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1722                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1723                         }
1724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1725                         ndr->offset = _relative_save_offset;
1726                 }
1727         }
1728         return NDR_ERR_SUCCESS;
1729 }
1730
1731 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1732 {
1733         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1734         ndr->depth++;
1735         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1736         ndr->depth++;
1737         if (r->secdesc) {
1738                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1739         }
1740         ndr->depth--;
1741         ndr->depth--;
1742 }
1743
1744 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
1745 {
1746         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
1747 }
1748
1749 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1750 {
1751         if (ndr_flags & NDR_SCALARS) {
1752                 NDR_CHECK(ndr_push_align(ndr, 4));
1753                 {
1754                         uint32_t _flags_save_string = ndr->flags;
1755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1756                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1757                         ndr->flags = _flags_save_string;
1758                 }
1759                 {
1760                         uint32_t _flags_save_string = ndr->flags;
1761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1762                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1763                         ndr->flags = _flags_save_string;
1764                 }
1765                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 {
1769                         uint32_t _flags_save_string = ndr->flags;
1770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1771                         if (r->printername) {
1772                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1773                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1774                         }
1775                         ndr->flags = _flags_save_string;
1776                 }
1777                 {
1778                         uint32_t _flags_save_string = ndr->flags;
1779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1780                         if (r->servername) {
1781                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1783                         }
1784                         ndr->flags = _flags_save_string;
1785                 }
1786         }
1787         return NDR_ERR_SUCCESS;
1788 }
1789
1790 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1791 {
1792         uint32_t _ptr_printername;
1793         TALLOC_CTX *_mem_save_printername_0;
1794         uint32_t _ptr_servername;
1795         TALLOC_CTX *_mem_save_servername_0;
1796         if (ndr_flags & NDR_SCALARS) {
1797                 NDR_CHECK(ndr_pull_align(ndr, 4));
1798                 {
1799                         uint32_t _flags_save_string = ndr->flags;
1800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1801                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1802                         if (_ptr_printername) {
1803                                 NDR_PULL_ALLOC(ndr, r->printername);
1804                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1805                         } else {
1806                                 r->printername = NULL;
1807                         }
1808                         ndr->flags = _flags_save_string;
1809                 }
1810                 {
1811                         uint32_t _flags_save_string = ndr->flags;
1812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1813                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1814                         if (_ptr_servername) {
1815                                 NDR_PULL_ALLOC(ndr, r->servername);
1816                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1817                         } else {
1818                                 r->servername = NULL;
1819                         }
1820                         ndr->flags = _flags_save_string;
1821                 }
1822                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1823         }
1824         if (ndr_flags & NDR_BUFFERS) {
1825                 {
1826                         uint32_t _flags_save_string = ndr->flags;
1827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1828                         if (r->printername) {
1829                                 uint32_t _relative_save_offset;
1830                                 _relative_save_offset = ndr->offset;
1831                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1832                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1833                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1834                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1835                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1836                                 ndr->offset = _relative_save_offset;
1837                         }
1838                         ndr->flags = _flags_save_string;
1839                 }
1840                 {
1841                         uint32_t _flags_save_string = ndr->flags;
1842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1843                         if (r->servername) {
1844                                 uint32_t _relative_save_offset;
1845                                 _relative_save_offset = ndr->offset;
1846                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1847                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1848                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1849                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1850                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1851                                 ndr->offset = _relative_save_offset;
1852                         }
1853                         ndr->flags = _flags_save_string;
1854                 }
1855         }
1856         return NDR_ERR_SUCCESS;
1857 }
1858
1859 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1860 {
1861         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1862         ndr->depth++;
1863         ndr_print_ptr(ndr, "printername", r->printername);
1864         ndr->depth++;
1865         if (r->printername) {
1866                 ndr_print_string(ndr, "printername", r->printername);
1867         }
1868         ndr->depth--;
1869         ndr_print_ptr(ndr, "servername", r->servername);
1870         ndr->depth++;
1871         if (r->servername) {
1872                 ndr_print_string(ndr, "servername", r->servername);
1873         }
1874         ndr->depth--;
1875         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1876         ndr->depth--;
1877 }
1878
1879 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
1880 {
1881         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
1882 }
1883
1884 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1885 {
1886         if (ndr_flags & NDR_SCALARS) {
1887                 NDR_CHECK(ndr_push_align(ndr, 4));
1888                 {
1889                         uint32_t _flags_save_string = ndr->flags;
1890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1891                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1898                         ndr->flags = _flags_save_string;
1899                 }
1900                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1903         }
1904         if (ndr_flags & NDR_BUFFERS) {
1905                 {
1906                         uint32_t _flags_save_string = ndr->flags;
1907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1908                         if (r->printername) {
1909                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1910                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1911                         }
1912                         ndr->flags = _flags_save_string;
1913                 }
1914                 {
1915                         uint32_t _flags_save_string = ndr->flags;
1916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1917                         if (r->portname) {
1918                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1919                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1920                         }
1921                         ndr->flags = _flags_save_string;
1922                 }
1923         }
1924         return NDR_ERR_SUCCESS;
1925 }
1926
1927 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1928 {
1929         uint32_t _ptr_printername;
1930         TALLOC_CTX *_mem_save_printername_0;
1931         uint32_t _ptr_portname;
1932         TALLOC_CTX *_mem_save_portname_0;
1933         if (ndr_flags & NDR_SCALARS) {
1934                 NDR_CHECK(ndr_pull_align(ndr, 4));
1935                 {
1936                         uint32_t _flags_save_string = ndr->flags;
1937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1938                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1939                         if (_ptr_printername) {
1940                                 NDR_PULL_ALLOC(ndr, r->printername);
1941                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1942                         } else {
1943                                 r->printername = NULL;
1944                         }
1945                         ndr->flags = _flags_save_string;
1946                 }
1947                 {
1948                         uint32_t _flags_save_string = ndr->flags;
1949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1951                         if (_ptr_portname) {
1952                                 NDR_PULL_ALLOC(ndr, r->portname);
1953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1954                         } else {
1955                                 r->portname = NULL;
1956                         }
1957                         ndr->flags = _flags_save_string;
1958                 }
1959                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1962         }
1963         if (ndr_flags & NDR_BUFFERS) {
1964                 {
1965                         uint32_t _flags_save_string = ndr->flags;
1966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1967                         if (r->printername) {
1968                                 uint32_t _relative_save_offset;
1969                                 _relative_save_offset = ndr->offset;
1970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1971                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1972                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1975                                 ndr->offset = _relative_save_offset;
1976                         }
1977                         ndr->flags = _flags_save_string;
1978                 }
1979                 {
1980                         uint32_t _flags_save_string = ndr->flags;
1981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1982                         if (r->portname) {
1983                                 uint32_t _relative_save_offset;
1984                                 _relative_save_offset = ndr->offset;
1985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1986                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1987                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1990                                 ndr->offset = _relative_save_offset;
1991                         }
1992                         ndr->flags = _flags_save_string;
1993                 }
1994         }
1995         return NDR_ERR_SUCCESS;
1996 }
1997
1998 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1999 {
2000         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2001         ndr->depth++;
2002         ndr_print_ptr(ndr, "printername", r->printername);
2003         ndr->depth++;
2004         if (r->printername) {
2005                 ndr_print_string(ndr, "printername", r->printername);
2006         }
2007         ndr->depth--;
2008         ndr_print_ptr(ndr, "portname", r->portname);
2009         ndr->depth++;
2010         if (r->portname) {
2011                 ndr_print_string(ndr, "portname", r->portname);
2012         }
2013         ndr->depth--;
2014         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2015         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2016         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2017         ndr->depth--;
2018 }
2019
2020 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2021 {
2022         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2023 }
2024
2025 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2026 {
2027         if (ndr_flags & NDR_SCALARS) {
2028                 NDR_CHECK(ndr_push_align(ndr, 4));
2029                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2030         }
2031         if (ndr_flags & NDR_BUFFERS) {
2032         }
2033         return NDR_ERR_SUCCESS;
2034 }
2035
2036 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2037 {
2038         if (ndr_flags & NDR_SCALARS) {
2039                 NDR_CHECK(ndr_pull_align(ndr, 4));
2040                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2041         }
2042         if (ndr_flags & NDR_BUFFERS) {
2043         }
2044         return NDR_ERR_SUCCESS;
2045 }
2046
2047 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2048 {
2049         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2050         ndr->depth++;
2051         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2052         ndr->depth--;
2053 }
2054
2055 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2056 {
2057         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2058 }
2059
2060 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2061 {
2062         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2063         return NDR_ERR_SUCCESS;
2064 }
2065
2066 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2067 {
2068         uint32_t v;
2069         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2070         *r = v;
2071         return NDR_ERR_SUCCESS;
2072 }
2073
2074 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2075 {
2076         ndr_print_uint32(ndr, name, r);
2077         ndr->depth++;
2078         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2079         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2080         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2081         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2082         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2083         ndr->depth--;
2084 }
2085
2086 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2087 {
2088         if (ndr_flags & NDR_SCALARS) {
2089                 NDR_CHECK(ndr_push_align(ndr, 4));
2090                 {
2091                         uint32_t _flags_save_string = ndr->flags;
2092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2093                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2094                         ndr->flags = _flags_save_string;
2095                 }
2096                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2097         }
2098         if (ndr_flags & NDR_BUFFERS) {
2099                 {
2100                         uint32_t _flags_save_string = ndr->flags;
2101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2102                         if (r->guid) {
2103                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2104                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2105                         }
2106                         ndr->flags = _flags_save_string;
2107                 }
2108         }
2109         return NDR_ERR_SUCCESS;
2110 }
2111
2112 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2113 {
2114         uint32_t _ptr_guid;
2115         TALLOC_CTX *_mem_save_guid_0;
2116         if (ndr_flags & NDR_SCALARS) {
2117                 NDR_CHECK(ndr_pull_align(ndr, 4));
2118                 {
2119                         uint32_t _flags_save_string = ndr->flags;
2120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2121                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2122                         if (_ptr_guid) {
2123                                 NDR_PULL_ALLOC(ndr, r->guid);
2124                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2125                         } else {
2126                                 r->guid = NULL;
2127                         }
2128                         ndr->flags = _flags_save_string;
2129                 }
2130                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2131         }
2132         if (ndr_flags & NDR_BUFFERS) {
2133                 {
2134                         uint32_t _flags_save_string = ndr->flags;
2135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2136                         if (r->guid) {
2137                                 uint32_t _relative_save_offset;
2138                                 _relative_save_offset = ndr->offset;
2139                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2140                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2141                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2142                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2143                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2144                                 ndr->offset = _relative_save_offset;
2145                         }
2146                         ndr->flags = _flags_save_string;
2147                 }
2148         }
2149         return NDR_ERR_SUCCESS;
2150 }
2151
2152 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2153 {
2154         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2155         ndr->depth++;
2156         ndr_print_ptr(ndr, "guid", r->guid);
2157         ndr->depth++;
2158         if (r->guid) {
2159                 ndr_print_string(ndr, "guid", r->guid);
2160         }
2161         ndr->depth--;
2162         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2163         ndr->depth--;
2164 }
2165
2166 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2167 {
2168         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2169 }
2170
2171 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2172 {
2173         if (ndr_flags & NDR_SCALARS) {
2174                 NDR_CHECK(ndr_push_align(ndr, 4));
2175                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2176         }
2177         if (ndr_flags & NDR_BUFFERS) {
2178                 if (r->devmode) {
2179                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2180                         {
2181                                 struct ndr_push *_ndr_devmode;
2182                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2183                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2184                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2185                         }
2186                 }
2187         }
2188         return NDR_ERR_SUCCESS;
2189 }
2190
2191 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2192 {
2193         uint32_t _ptr_devmode;
2194         TALLOC_CTX *_mem_save_devmode_0;
2195         if (ndr_flags & NDR_SCALARS) {
2196                 NDR_CHECK(ndr_pull_align(ndr, 4));
2197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2198                 if (_ptr_devmode) {
2199                         NDR_PULL_ALLOC(ndr, r->devmode);
2200                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2201                 } else {
2202                         r->devmode = NULL;
2203                 }
2204         }
2205         if (ndr_flags & NDR_BUFFERS) {
2206                 if (r->devmode) {
2207                         uint32_t _relative_save_offset;
2208                         _relative_save_offset = ndr->offset;
2209                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2210                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2211                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2212                         {
2213                                 struct ndr_pull *_ndr_devmode;
2214                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2215                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2216                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2217                         }
2218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2219                         ndr->offset = _relative_save_offset;
2220                 }
2221         }
2222         return NDR_ERR_SUCCESS;
2223 }
2224
2225 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2226 {
2227         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2228         ndr->depth++;
2229         ndr_print_ptr(ndr, "devmode", r->devmode);
2230         ndr->depth++;
2231         if (r->devmode) {
2232                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2233         }
2234         ndr->depth--;
2235         ndr->depth--;
2236 }
2237
2238 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2239 {
2240         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2241         if (ndr_flags & NDR_SCALARS) {
2242                 int level = ndr_push_get_switch_value(ndr, r);
2243                 switch (level) {
2244                         case 0: {
2245                                 NDR_CHECK(ndr_push_align(ndr, 4));
2246                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2247                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2248                         break; }
2249
2250                         case 1: {
2251                                 NDR_CHECK(ndr_push_align(ndr, 4));
2252                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2253                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2254                         break; }
2255
2256                         case 2: {
2257                                 NDR_CHECK(ndr_push_align(ndr, 4));
2258                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2259                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2260                         break; }
2261
2262                         case 3: {
2263                                 NDR_CHECK(ndr_push_align(ndr, 4));
2264                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2265                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2266                         break; }
2267
2268                         case 4: {
2269                                 NDR_CHECK(ndr_push_align(ndr, 4));
2270                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2271                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2272                         break; }
2273
2274                         case 5: {
2275                                 NDR_CHECK(ndr_push_align(ndr, 4));
2276                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2277                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2278                         break; }
2279
2280                         case 6: {
2281                                 NDR_CHECK(ndr_push_align(ndr, 4));
2282                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2283                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2284                         break; }
2285
2286                         case 7: {
2287                                 NDR_CHECK(ndr_push_align(ndr, 4));
2288                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2289                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2290                         break; }
2291
2292                         case 8: {
2293                                 NDR_CHECK(ndr_push_align(ndr, 4));
2294                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2295                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2296                         break; }
2297
2298                         case 9: {
2299                                 NDR_CHECK(ndr_push_align(ndr, 4));
2300                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2301                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2302                         break; }
2303
2304                         default: {
2305                         break; }
2306
2307                 }
2308         }
2309         if (ndr_flags & NDR_BUFFERS) {
2310                 int level = ndr_push_get_switch_value(ndr, r);
2311                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2312                 switch (level) {
2313                         case 0:
2314                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2315                         break;
2316
2317                         case 1:
2318                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2319                         break;
2320
2321                         case 2:
2322                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2323                         break;
2324
2325                         case 3:
2326                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2327                         break;
2328
2329                         case 4:
2330                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2331                         break;
2332
2333                         case 5:
2334                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2335                         break;
2336
2337                         case 6:
2338                         break;
2339
2340                         case 7:
2341                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2342                         break;
2343
2344                         case 8:
2345                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2346                         break;
2347
2348                         case 9:
2349                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2350                         break;
2351
2352                         default:
2353                         break;
2354
2355                 }
2356         }
2357         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2358         return NDR_ERR_SUCCESS;
2359 }
2360
2361 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2362 {
2363         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2364         int level;
2365         level = ndr_pull_get_switch_value(ndr, r);
2366         if (ndr_flags & NDR_SCALARS) {
2367                 switch (level) {
2368                         case 0: {
2369                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2370                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2371                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2372                         break; }
2373
2374                         case 1: {
2375                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2376                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2377                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2378                         break; }
2379
2380                         case 2: {
2381                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2382                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2383                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2384                         break; }
2385
2386                         case 3: {
2387                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2388                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2389                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2390                         break; }
2391
2392                         case 4: {
2393                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2394                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2395                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2396                         break; }
2397
2398                         case 5: {
2399                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2400                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2401                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2402                         break; }
2403
2404                         case 6: {
2405                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2406                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2407                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2408                         break; }
2409
2410                         case 7: {
2411                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2412                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2413                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2414                         break; }
2415
2416                         case 8: {
2417                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2418                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2419                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2420                         break; }
2421
2422                         case 9: {
2423                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2424                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2425                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2426                         break; }
2427
2428                         default: {
2429                         break; }
2430
2431                 }
2432         }
2433         if (ndr_flags & NDR_BUFFERS) {
2434                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2435                 switch (level) {
2436                         case 0:
2437                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2438                         break;
2439
2440                         case 1:
2441                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2442                         break;
2443
2444                         case 2:
2445                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2446                         break;
2447
2448                         case 3:
2449                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2450                         break;
2451
2452                         case 4:
2453                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2454                         break;
2455
2456                         case 5:
2457                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2458                         break;
2459
2460                         case 6:
2461                         break;
2462
2463                         case 7:
2464                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2465                         break;
2466
2467                         case 8:
2468                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2469                         break;
2470
2471                         case 9:
2472                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2473                         break;
2474
2475                         default:
2476                         break;
2477
2478                 }
2479         }
2480         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2481         return NDR_ERR_SUCCESS;
2482 }
2483
2484 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2485 {
2486         int level;
2487         level = ndr_print_get_switch_value(ndr, r);
2488         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2489         switch (level) {
2490                 case 0:
2491                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2492                 break;
2493
2494                 case 1:
2495                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2496                 break;
2497
2498                 case 2:
2499                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2500                 break;
2501
2502                 case 3:
2503                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2504                 break;
2505
2506                 case 4:
2507                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2508                 break;
2509
2510                 case 5:
2511                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2512                 break;
2513
2514                 case 6:
2515                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2516                 break;
2517
2518                 case 7:
2519                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2520                 break;
2521
2522                 case 8:
2523                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2524                 break;
2525
2526                 case 9:
2527                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2528                 break;
2529
2530                 default:
2531                 break;
2532
2533         }
2534 }
2535
2536 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2537 {
2538         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2539 }
2540
2541 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2542 {
2543         if (ndr_flags & NDR_SCALARS) {
2544                 NDR_CHECK(ndr_push_align(ndr, 4));
2545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2547         }
2548         if (ndr_flags & NDR_BUFFERS) {
2549                 if (r->devmode) {
2550                         {
2551                                 struct ndr_push *_ndr_devmode;
2552                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2553                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2554                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2555                         }
2556                 }
2557         }
2558         return NDR_ERR_SUCCESS;
2559 }
2560
2561 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2562 {
2563         uint32_t _ptr_devmode;
2564         TALLOC_CTX *_mem_save_devmode_0;
2565         if (ndr_flags & NDR_SCALARS) {
2566                 NDR_CHECK(ndr_pull_align(ndr, 4));
2567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2569                 if (_ptr_devmode) {
2570                         NDR_PULL_ALLOC(ndr, r->devmode);
2571                 } else {
2572                         r->devmode = NULL;
2573                 }
2574         }
2575         if (ndr_flags & NDR_BUFFERS) {
2576                 if (r->devmode) {
2577                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2578                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2579                         {
2580                                 struct ndr_pull *_ndr_devmode;
2581                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2582                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2583                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2584                         }
2585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2586                 }
2587         }
2588         return NDR_ERR_SUCCESS;
2589 }
2590
2591 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2592 {
2593         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2594         ndr->depth++;
2595         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);
2596         ndr_print_ptr(ndr, "devmode", r->devmode);
2597         ndr->depth++;
2598         if (r->devmode) {
2599                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2600         }
2601         ndr->depth--;
2602         ndr->depth--;
2603 }
2604
2605 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2606 {
2607         if (ndr_flags & NDR_SCALARS) {
2608                 NDR_CHECK(ndr_push_align(ndr, 4));
2609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2610                 {
2611                         uint32_t _flags_save_string = ndr->flags;
2612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2613                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2614                         ndr->flags = _flags_save_string;
2615                 }
2616                 {
2617                         uint32_t _flags_save_string = ndr->flags;
2618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2619                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2620                         ndr->flags = _flags_save_string;
2621                 }
2622                 {
2623                         uint32_t _flags_save_string = ndr->flags;
2624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2625                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2626                         ndr->flags = _flags_save_string;
2627                 }
2628                 {
2629                         uint32_t _flags_save_string = ndr->flags;
2630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2631                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2632                         ndr->flags = _flags_save_string;
2633                 }
2634                 {
2635                         uint32_t _flags_save_string = ndr->flags;
2636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2638                         ndr->flags = _flags_save_string;
2639                 }
2640                 {
2641                         uint32_t _flags_save_string = ndr->flags;
2642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2643                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2644                         ndr->flags = _flags_save_string;
2645                 }
2646                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2651                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2652         }
2653         if (ndr_flags & NDR_BUFFERS) {
2654                 {
2655                         uint32_t _flags_save_string = ndr->flags;
2656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2657                         if (r->printer_name) {
2658                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2659                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2660                         }
2661                         ndr->flags = _flags_save_string;
2662                 }
2663                 {
2664                         uint32_t _flags_save_string = ndr->flags;
2665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2666                         if (r->server_name) {
2667                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2668                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2669                         }
2670                         ndr->flags = _flags_save_string;
2671                 }
2672                 {
2673                         uint32_t _flags_save_string = ndr->flags;
2674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2675                         if (r->user_name) {
2676                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2677                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2678                         }
2679                         ndr->flags = _flags_save_string;
2680                 }
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         if (r->document_name) {
2685                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2686                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2687                         }
2688                         ndr->flags = _flags_save_string;
2689                 }
2690                 {
2691                         uint32_t _flags_save_string = ndr->flags;
2692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2693                         if (r->data_type) {
2694                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2695                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2696                         }
2697                         ndr->flags = _flags_save_string;
2698                 }
2699                 {
2700                         uint32_t _flags_save_string = ndr->flags;
2701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2702                         if (r->text_status) {
2703                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2704                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2705                         }
2706                         ndr->flags = _flags_save_string;
2707                 }
2708         }
2709         return NDR_ERR_SUCCESS;
2710 }
2711
2712 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2713 {
2714         uint32_t _ptr_printer_name;
2715         TALLOC_CTX *_mem_save_printer_name_0;
2716         uint32_t _ptr_server_name;
2717         TALLOC_CTX *_mem_save_server_name_0;
2718         uint32_t _ptr_user_name;
2719         TALLOC_CTX *_mem_save_user_name_0;
2720         uint32_t _ptr_document_name;
2721         TALLOC_CTX *_mem_save_document_name_0;
2722         uint32_t _ptr_data_type;
2723         TALLOC_CTX *_mem_save_data_type_0;
2724         uint32_t _ptr_text_status;
2725         TALLOC_CTX *_mem_save_text_status_0;
2726         if (ndr_flags & NDR_SCALARS) {
2727                 NDR_CHECK(ndr_pull_align(ndr, 4));
2728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2729                 {
2730                         uint32_t _flags_save_string = ndr->flags;
2731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2732                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2733                         if (_ptr_printer_name) {
2734                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2736                         } else {
2737                                 r->printer_name = NULL;
2738                         }
2739                         ndr->flags = _flags_save_string;
2740                 }
2741                 {
2742                         uint32_t _flags_save_string = ndr->flags;
2743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2745                         if (_ptr_server_name) {
2746                                 NDR_PULL_ALLOC(ndr, r->server_name);
2747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2748                         } else {
2749                                 r->server_name = NULL;
2750                         }
2751                         ndr->flags = _flags_save_string;
2752                 }
2753                 {
2754                         uint32_t _flags_save_string = ndr->flags;
2755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2757                         if (_ptr_user_name) {
2758                                 NDR_PULL_ALLOC(ndr, r->user_name);
2759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2760                         } else {
2761                                 r->user_name = NULL;
2762                         }
2763                         ndr->flags = _flags_save_string;
2764                 }
2765                 {
2766                         uint32_t _flags_save_string = ndr->flags;
2767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2768                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2769                         if (_ptr_document_name) {
2770                                 NDR_PULL_ALLOC(ndr, r->document_name);
2771                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2772                         } else {
2773                                 r->document_name = NULL;
2774                         }
2775                         ndr->flags = _flags_save_string;
2776                 }
2777                 {
2778                         uint32_t _flags_save_string = ndr->flags;
2779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2780                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2781                         if (_ptr_data_type) {
2782                                 NDR_PULL_ALLOC(ndr, r->data_type);
2783                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2784                         } else {
2785                                 r->data_type = NULL;
2786                         }
2787                         ndr->flags = _flags_save_string;
2788                 }
2789                 {
2790                         uint32_t _flags_save_string = ndr->flags;
2791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2792                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2793                         if (_ptr_text_status) {
2794                                 NDR_PULL_ALLOC(ndr, r->text_status);
2795                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2796                         } else {
2797                                 r->text_status = NULL;
2798                         }
2799                         ndr->flags = _flags_save_string;
2800                 }
2801                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2803                 if (r->priority > 99) {
2804                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2805                 }
2806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2809                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2810         }
2811         if (ndr_flags & NDR_BUFFERS) {
2812                 {
2813                         uint32_t _flags_save_string = ndr->flags;
2814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2815                         if (r->printer_name) {
2816                                 uint32_t _relative_save_offset;
2817                                 _relative_save_offset = ndr->offset;
2818                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2819                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2820                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2821                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2822                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2823                                 ndr->offset = _relative_save_offset;
2824                         }
2825                         ndr->flags = _flags_save_string;
2826                 }
2827                 {
2828                         uint32_t _flags_save_string = ndr->flags;
2829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2830                         if (r->server_name) {
2831                                 uint32_t _relative_save_offset;
2832                                 _relative_save_offset = ndr->offset;
2833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2834                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2835                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2838                                 ndr->offset = _relative_save_offset;
2839                         }
2840                         ndr->flags = _flags_save_string;
2841                 }
2842                 {
2843                         uint32_t _flags_save_string = ndr->flags;
2844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2845                         if (r->user_name) {
2846                                 uint32_t _relative_save_offset;
2847                                 _relative_save_offset = ndr->offset;
2848                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2849                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2850                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2851                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2852                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2853                                 ndr->offset = _relative_save_offset;
2854                         }
2855                         ndr->flags = _flags_save_string;
2856                 }
2857                 {
2858                         uint32_t _flags_save_string = ndr->flags;
2859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2860                         if (r->document_name) {
2861                                 uint32_t _relative_save_offset;
2862                                 _relative_save_offset = ndr->offset;
2863                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2864                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2865                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2866                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2867                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2868                                 ndr->offset = _relative_save_offset;
2869                         }
2870                         ndr->flags = _flags_save_string;
2871                 }
2872                 {
2873                         uint32_t _flags_save_string = ndr->flags;
2874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2875                         if (r->data_type) {
2876                                 uint32_t _relative_save_offset;
2877                                 _relative_save_offset = ndr->offset;
2878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2879                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2880                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2883                                 ndr->offset = _relative_save_offset;
2884                         }
2885                         ndr->flags = _flags_save_string;
2886                 }
2887                 {
2888                         uint32_t _flags_save_string = ndr->flags;
2889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2890                         if (r->text_status) {
2891                                 uint32_t _relative_save_offset;
2892                                 _relative_save_offset = ndr->offset;
2893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2894                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2895                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2896                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2897                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2898                                 ndr->offset = _relative_save_offset;
2899                         }
2900                         ndr->flags = _flags_save_string;
2901                 }
2902         }
2903         return NDR_ERR_SUCCESS;
2904 }
2905
2906 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2907 {
2908         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2909         ndr->depth++;
2910         ndr_print_uint32(ndr, "job_id", r->job_id);
2911         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2912         ndr->depth++;
2913         if (r->printer_name) {
2914                 ndr_print_string(ndr, "printer_name", r->printer_name);
2915         }
2916         ndr->depth--;
2917         ndr_print_ptr(ndr, "server_name", r->server_name);
2918         ndr->depth++;
2919         if (r->server_name) {
2920                 ndr_print_string(ndr, "server_name", r->server_name);
2921         }
2922         ndr->depth--;
2923         ndr_print_ptr(ndr, "user_name", r->user_name);
2924         ndr->depth++;
2925         if (r->user_name) {
2926                 ndr_print_string(ndr, "user_name", r->user_name);
2927         }
2928         ndr->depth--;
2929         ndr_print_ptr(ndr, "document_name", r->document_name);
2930         ndr->depth++;
2931         if (r->document_name) {
2932                 ndr_print_string(ndr, "document_name", r->document_name);
2933         }
2934         ndr->depth--;
2935         ndr_print_ptr(ndr, "data_type", r->data_type);
2936         ndr->depth++;
2937         if (r->data_type) {
2938                 ndr_print_string(ndr, "data_type", r->data_type);
2939         }
2940         ndr->depth--;
2941         ndr_print_ptr(ndr, "text_status", r->text_status);
2942         ndr->depth++;
2943         if (r->text_status) {
2944                 ndr_print_string(ndr, "text_status", r->text_status);
2945         }
2946         ndr->depth--;
2947         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2948         ndr_print_uint32(ndr, "priority", r->priority);
2949         ndr_print_uint32(ndr, "position", r->position);
2950         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2951         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2952         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2953         ndr->depth--;
2954 }
2955
2956 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
2957 {
2958         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
2959 }
2960
2961 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2962 {
2963         if (ndr_flags & NDR_SCALARS) {
2964                 NDR_CHECK(ndr_push_align(ndr, 4));
2965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2966                 {
2967                         uint32_t _flags_save_string = ndr->flags;
2968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2970                         ndr->flags = _flags_save_string;
2971                 }
2972                 {
2973                         uint32_t _flags_save_string = ndr->flags;
2974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2976                         ndr->flags = _flags_save_string;
2977                 }
2978                 {
2979                         uint32_t _flags_save_string = ndr->flags;
2980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2982                         ndr->flags = _flags_save_string;
2983                 }
2984                 {
2985                         uint32_t _flags_save_string = ndr->flags;
2986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2988                         ndr->flags = _flags_save_string;
2989                 }
2990                 {
2991                         uint32_t _flags_save_string = ndr->flags;
2992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2994                         ndr->flags = _flags_save_string;
2995                 }
2996                 {
2997                         uint32_t _flags_save_string = ndr->flags;
2998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2999                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3000                         ndr->flags = _flags_save_string;
3001                 }
3002                 {
3003                         uint32_t _flags_save_string = ndr->flags;
3004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3005                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3006                         ndr->flags = _flags_save_string;
3007                 }
3008                 {
3009                         uint32_t _flags_save_string = ndr->flags;
3010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3012                         ndr->flags = _flags_save_string;
3013                 }
3014                 {
3015                         uint32_t _flags_save_string = ndr->flags;
3016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3017                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3018                         ndr->flags = _flags_save_string;
3019                 }
3020                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3021                 {
3022                         uint32_t _flags_save_string = ndr->flags;
3023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3024                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3025                         ndr->flags = _flags_save_string;
3026                 }
3027                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3028                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3035                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3038         }
3039         if (ndr_flags & NDR_BUFFERS) {
3040                 {
3041                         uint32_t _flags_save_string = ndr->flags;
3042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3043                         if (r->printer_name) {
3044                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3045                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3046                         }
3047                         ndr->flags = _flags_save_string;
3048                 }
3049                 {
3050                         uint32_t _flags_save_string = ndr->flags;
3051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3052                         if (r->server_name) {
3053                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3054                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3055                         }
3056                         ndr->flags = _flags_save_string;
3057                 }
3058                 {
3059                         uint32_t _flags_save_string = ndr->flags;
3060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3061                         if (r->user_name) {
3062                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3063                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3064                         }
3065                         ndr->flags = _flags_save_string;
3066                 }
3067                 {
3068                         uint32_t _flags_save_string = ndr->flags;
3069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3070                         if (r->document_name) {
3071                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3072                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3073                         }
3074                         ndr->flags = _flags_save_string;
3075                 }
3076                 {
3077                         uint32_t _flags_save_string = ndr->flags;
3078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3079                         if (r->notify_name) {
3080                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3081                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3082                         }
3083                         ndr->flags = _flags_save_string;
3084                 }
3085                 {
3086                         uint32_t _flags_save_string = ndr->flags;
3087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3088                         if (r->data_type) {
3089                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3090                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3091                         }
3092                         ndr->flags = _flags_save_string;
3093                 }
3094                 {
3095                         uint32_t _flags_save_string = ndr->flags;
3096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3097                         if (r->print_processor) {
3098                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3099                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3100                         }
3101                         ndr->flags = _flags_save_string;
3102                 }
3103                 {
3104                         uint32_t _flags_save_string = ndr->flags;
3105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3106                         if (r->parameters) {
3107                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3108                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3109                         }
3110                         ndr->flags = _flags_save_string;
3111                 }
3112                 {
3113                         uint32_t _flags_save_string = ndr->flags;
3114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3115                         if (r->driver_name) {
3116                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3117                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3118                         }
3119                         ndr->flags = _flags_save_string;
3120                 }
3121                 if (r->devmode) {
3122                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3123                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3124                 }
3125                 {
3126                         uint32_t _flags_save_string = ndr->flags;
3127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3128                         if (r->text_status) {
3129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3131                         }
3132                         ndr->flags = _flags_save_string;
3133                 }
3134                 if (r->secdesc) {
3135                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3136                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3137                 }
3138         }
3139         return NDR_ERR_SUCCESS;
3140 }
3141
3142 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3143 {
3144         uint32_t _ptr_printer_name;
3145         TALLOC_CTX *_mem_save_printer_name_0;
3146         uint32_t _ptr_server_name;
3147         TALLOC_CTX *_mem_save_server_name_0;
3148         uint32_t _ptr_user_name;
3149         TALLOC_CTX *_mem_save_user_name_0;
3150         uint32_t _ptr_document_name;
3151         TALLOC_CTX *_mem_save_document_name_0;
3152         uint32_t _ptr_notify_name;
3153         TALLOC_CTX *_mem_save_notify_name_0;
3154         uint32_t _ptr_data_type;
3155         TALLOC_CTX *_mem_save_data_type_0;
3156         uint32_t _ptr_print_processor;
3157         TALLOC_CTX *_mem_save_print_processor_0;
3158         uint32_t _ptr_parameters;
3159         TALLOC_CTX *_mem_save_parameters_0;
3160         uint32_t _ptr_driver_name;
3161         TALLOC_CTX *_mem_save_driver_name_0;
3162         uint32_t _ptr_devmode;
3163         TALLOC_CTX *_mem_save_devmode_0;
3164         uint32_t _ptr_text_status;
3165         TALLOC_CTX *_mem_save_text_status_0;
3166         uint32_t _ptr_secdesc;
3167         TALLOC_CTX *_mem_save_secdesc_0;
3168         if (ndr_flags & NDR_SCALARS) {
3169                 NDR_CHECK(ndr_pull_align(ndr, 4));
3170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3171                 {
3172                         uint32_t _flags_save_string = ndr->flags;
3173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3174                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3175                         if (_ptr_printer_name) {
3176                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3177                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3178                         } else {
3179                                 r->printer_name = NULL;
3180                         }
3181                         ndr->flags = _flags_save_string;
3182                 }
3183                 {
3184                         uint32_t _flags_save_string = ndr->flags;
3185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3186                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3187                         if (_ptr_server_name) {
3188                                 NDR_PULL_ALLOC(ndr, r->server_name);
3189                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3190                         } else {
3191                                 r->server_name = NULL;
3192                         }
3193                         ndr->flags = _flags_save_string;
3194                 }
3195                 {
3196                         uint32_t _flags_save_string = ndr->flags;
3197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3198                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3199                         if (_ptr_user_name) {
3200                                 NDR_PULL_ALLOC(ndr, r->user_name);
3201                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3202                         } else {
3203                                 r->user_name = NULL;
3204                         }
3205                         ndr->flags = _flags_save_string;
3206                 }
3207                 {
3208                         uint32_t _flags_save_string = ndr->flags;
3209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3210                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3211                         if (_ptr_document_name) {
3212                                 NDR_PULL_ALLOC(ndr, r->document_name);
3213                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3214                         } else {
3215                                 r->document_name = NULL;
3216                         }
3217                         ndr->flags = _flags_save_string;
3218                 }
3219                 {
3220                         uint32_t _flags_save_string = ndr->flags;
3221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3222                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3223                         if (_ptr_notify_name) {
3224                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3225                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3226                         } else {
3227                                 r->notify_name = NULL;
3228                         }
3229                         ndr->flags = _flags_save_string;
3230                 }
3231                 {
3232                         uint32_t _flags_save_string = ndr->flags;
3233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3234                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3235                         if (_ptr_data_type) {
3236                                 NDR_PULL_ALLOC(ndr, r->data_type);
3237                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3238                         } else {
3239                                 r->data_type = NULL;
3240                         }
3241                         ndr->flags = _flags_save_string;
3242                 }
3243                 {
3244                         uint32_t _flags_save_string = ndr->flags;
3245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3246                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3247                         if (_ptr_print_processor) {
3248                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3249                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3250                         } else {
3251                                 r->print_processor = NULL;
3252                         }
3253                         ndr->flags = _flags_save_string;
3254                 }
3255                 {
3256                         uint32_t _flags_save_string = ndr->flags;
3257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3258                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3259                         if (_ptr_parameters) {
3260                                 NDR_PULL_ALLOC(ndr, r->parameters);
3261                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3262                         } else {
3263                                 r->parameters = NULL;
3264                         }
3265                         ndr->flags = _flags_save_string;
3266                 }
3267                 {
3268                         uint32_t _flags_save_string = ndr->flags;
3269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3270                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3271                         if (_ptr_driver_name) {
3272                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3273                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3274                         } else {
3275                                 r->driver_name = NULL;
3276                         }
3277                         ndr->flags = _flags_save_string;
3278                 }
3279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3280                 if (_ptr_devmode) {
3281                         NDR_PULL_ALLOC(ndr, r->devmode);
3282                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3283                 } else {
3284                         r->devmode = NULL;
3285                 }
3286                 {
3287                         uint32_t _flags_save_string = ndr->flags;
3288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3289                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3290                         if (_ptr_text_status) {
3291                                 NDR_PULL_ALLOC(ndr, r->text_status);
3292                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3293                         } else {
3294                                 r->text_status = NULL;
3295                         }
3296                         ndr->flags = _flags_save_string;
3297                 }
3298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3299                 if (_ptr_secdesc) {
3300                         NDR_PULL_ALLOC(ndr, r->secdesc);
3301                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3302                 } else {
3303                         r->secdesc = NULL;
3304                 }
3305                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3307                 if (r->priority > 99) {
3308                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3309                 }
3310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3315                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3318         }
3319         if (ndr_flags & NDR_BUFFERS) {
3320                 {
3321                         uint32_t _flags_save_string = ndr->flags;
3322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3323                         if (r->printer_name) {
3324                                 uint32_t _relative_save_offset;
3325                                 _relative_save_offset = ndr->offset;
3326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3327                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3328                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3331                                 ndr->offset = _relative_save_offset;
3332                         }
3333                         ndr->flags = _flags_save_string;
3334                 }
3335                 {
3336                         uint32_t _flags_save_string = ndr->flags;
3337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3338                         if (r->server_name) {
3339                                 uint32_t _relative_save_offset;
3340                                 _relative_save_offset = ndr->offset;
3341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3342                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3343                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3344                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3346                                 ndr->offset = _relative_save_offset;
3347                         }
3348                         ndr->flags = _flags_save_string;
3349                 }
3350                 {
3351                         uint32_t _flags_save_string = ndr->flags;
3352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3353                         if (r->user_name) {
3354                                 uint32_t _relative_save_offset;
3355                                 _relative_save_offset = ndr->offset;
3356                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3357                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3358                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3359                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3360                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3361                                 ndr->offset = _relative_save_offset;
3362                         }
3363                         ndr->flags = _flags_save_string;
3364                 }
3365                 {
3366                         uint32_t _flags_save_string = ndr->flags;
3367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3368                         if (r->document_name) {
3369                                 uint32_t _relative_save_offset;
3370                                 _relative_save_offset = ndr->offset;
3371                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3372                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3373                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3374                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3375                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3376                                 ndr->offset = _relative_save_offset;
3377                         }
3378                         ndr->flags = _flags_save_string;
3379                 }
3380                 {
3381                         uint32_t _flags_save_string = ndr->flags;
3382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3383                         if (r->notify_name) {
3384                                 uint32_t _relative_save_offset;
3385                                 _relative_save_offset = ndr->offset;
3386                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3387                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3388                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3389                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3390                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3391                                 ndr->offset = _relative_save_offset;
3392                         }
3393                         ndr->flags = _flags_save_string;
3394                 }
3395                 {
3396                         uint32_t _flags_save_string = ndr->flags;
3397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3398                         if (r->data_type) {
3399                                 uint32_t _relative_save_offset;
3400                                 _relative_save_offset = ndr->offset;
3401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3402                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3403                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3404                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3406                                 ndr->offset = _relative_save_offset;
3407                         }
3408                         ndr->flags = _flags_save_string;
3409                 }
3410                 {
3411                         uint32_t _flags_save_string = ndr->flags;
3412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3413                         if (r->print_processor) {
3414                                 uint32_t _relative_save_offset;
3415                                 _relative_save_offset = ndr->offset;
3416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3417                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3418                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3421                                 ndr->offset = _relative_save_offset;
3422                         }
3423                         ndr->flags = _flags_save_string;
3424                 }
3425                 {
3426                         uint32_t _flags_save_string = ndr->flags;
3427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3428                         if (r->parameters) {
3429                                 uint32_t _relative_save_offset;
3430                                 _relative_save_offset = ndr->offset;
3431                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3432                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3433                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3434                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3435                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3436                                 ndr->offset = _relative_save_offset;
3437                         }
3438                         ndr->flags = _flags_save_string;
3439                 }
3440                 {
3441                         uint32_t _flags_save_string = ndr->flags;
3442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3443                         if (r->driver_name) {
3444                                 uint32_t _relative_save_offset;
3445                                 _relative_save_offset = ndr->offset;
3446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3447                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3448                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3451                                 ndr->offset = _relative_save_offset;
3452                         }
3453                         ndr->flags = _flags_save_string;
3454                 }
3455                 if (r->devmode) {
3456                         uint32_t _relative_save_offset;
3457                         _relative_save_offset = ndr->offset;
3458                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3459                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3460                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3461                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3463                         ndr->offset = _relative_save_offset;
3464                 }
3465                 {
3466                         uint32_t _flags_save_string = ndr->flags;
3467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3468                         if (r->text_status) {
3469                                 uint32_t _relative_save_offset;
3470                                 _relative_save_offset = ndr->offset;
3471                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3472                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3473                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3474                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3475                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3476                                 ndr->offset = _relative_save_offset;
3477                         }
3478                         ndr->flags = _flags_save_string;
3479                 }
3480                 if (r->secdesc) {
3481                         uint32_t _relative_save_offset;
3482                         _relative_save_offset = ndr->offset;
3483                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3484                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3485                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3486                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3488                         ndr->offset = _relative_save_offset;
3489                 }
3490         }
3491         return NDR_ERR_SUCCESS;
3492 }
3493
3494 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3495 {
3496         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3497         ndr->depth++;
3498         ndr_print_uint32(ndr, "job_id", r->job_id);
3499         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3500         ndr->depth++;
3501         if (r->printer_name) {
3502                 ndr_print_string(ndr, "printer_name", r->printer_name);
3503         }
3504         ndr->depth--;
3505         ndr_print_ptr(ndr, "server_name", r->server_name);
3506         ndr->depth++;
3507         if (r->server_name) {
3508                 ndr_print_string(ndr, "server_name", r->server_name);
3509         }
3510         ndr->depth--;
3511         ndr_print_ptr(ndr, "user_name", r->user_name);
3512         ndr->depth++;
3513         if (r->user_name) {
3514                 ndr_print_string(ndr, "user_name", r->user_name);
3515         }
3516         ndr->depth--;
3517         ndr_print_ptr(ndr, "document_name", r->document_name);
3518         ndr->depth++;
3519         if (r->document_name) {
3520                 ndr_print_string(ndr, "document_name", r->document_name);
3521         }
3522         ndr->depth--;
3523         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3524         ndr->depth++;
3525         if (r->notify_name) {
3526                 ndr_print_string(ndr, "notify_name", r->notify_name);
3527         }
3528         ndr->depth--;
3529         ndr_print_ptr(ndr, "data_type", r->data_type);
3530         ndr->depth++;
3531         if (r->data_type) {
3532                 ndr_print_string(ndr, "data_type", r->data_type);
3533         }
3534         ndr->depth--;
3535         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3536         ndr->depth++;
3537         if (r->print_processor) {
3538                 ndr_print_string(ndr, "print_processor", r->print_processor);
3539         }
3540         ndr->depth--;
3541         ndr_print_ptr(ndr, "parameters", r->parameters);
3542         ndr->depth++;
3543         if (r->parameters) {
3544                 ndr_print_string(ndr, "parameters", r->parameters);
3545         }
3546         ndr->depth--;
3547         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3548         ndr->depth++;
3549         if (r->driver_name) {
3550                 ndr_print_string(ndr, "driver_name", r->driver_name);
3551         }
3552         ndr->depth--;
3553         ndr_print_ptr(ndr, "devmode", r->devmode);
3554         ndr->depth++;
3555         if (r->devmode) {
3556                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3557         }
3558         ndr->depth--;
3559         ndr_print_ptr(ndr, "text_status", r->text_status);
3560         ndr->depth++;
3561         if (r->text_status) {
3562                 ndr_print_string(ndr, "text_status", r->text_status);
3563         }
3564         ndr->depth--;
3565         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3566         ndr->depth++;
3567         if (r->secdesc) {
3568                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3569         }
3570         ndr->depth--;
3571         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3572         ndr_print_uint32(ndr, "priority", r->priority);
3573         ndr_print_uint32(ndr, "position", r->position);
3574         ndr_print_uint32(ndr, "start_time", r->start_time);
3575         ndr_print_uint32(ndr, "until_time", r->until_time);
3576         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3577         ndr_print_uint32(ndr, "size", r->size);
3578         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3579         ndr_print_uint32(ndr, "time", r->time);
3580         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3581         ndr->depth--;
3582 }
3583
3584 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
3585 {
3586         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
3587 }
3588
3589 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3590 {
3591         if (ndr_flags & NDR_SCALARS) {
3592                 NDR_CHECK(ndr_push_align(ndr, 4));
3593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3596         }
3597         if (ndr_flags & NDR_BUFFERS) {
3598         }
3599         return NDR_ERR_SUCCESS;
3600 }
3601
3602 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3603 {
3604         if (ndr_flags & NDR_SCALARS) {
3605                 NDR_CHECK(ndr_pull_align(ndr, 4));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3609         }
3610         if (ndr_flags & NDR_BUFFERS) {
3611         }
3612         return NDR_ERR_SUCCESS;
3613 }
3614
3615 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3616 {
3617         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3618         ndr->depth++;
3619         ndr_print_uint32(ndr, "job_id", r->job_id);
3620         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3621         ndr_print_uint32(ndr, "reserved", r->reserved);
3622         ndr->depth--;
3623 }
3624
3625 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
3626 {
3627         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
3628 }
3629
3630 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3631 {
3632         if (ndr_flags & NDR_SCALARS) {
3633                 NDR_CHECK(ndr_push_align(ndr, 4));
3634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3635                 {
3636                         uint32_t _flags_save_string = ndr->flags;
3637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3638                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3639                         ndr->flags = _flags_save_string;
3640                 }
3641                 {
3642                         uint32_t _flags_save_string = ndr->flags;
3643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3644                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3645                         ndr->flags = _flags_save_string;
3646                 }
3647                 {
3648                         uint32_t _flags_save_string = ndr->flags;
3649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3650                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3651                         ndr->flags = _flags_save_string;
3652                 }
3653                 {
3654                         uint32_t _flags_save_string = ndr->flags;
3655                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3656                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3657                         ndr->flags = _flags_save_string;
3658                 }
3659                 {
3660                         uint32_t _flags_save_string = ndr->flags;
3661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3662                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3663                         ndr->flags = _flags_save_string;
3664                 }
3665                 {
3666                         uint32_t _flags_save_string = ndr->flags;
3667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3668                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3669                         ndr->flags = _flags_save_string;
3670                 }
3671                 {
3672                         uint32_t _flags_save_string = ndr->flags;
3673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3674                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3675                         ndr->flags = _flags_save_string;
3676                 }
3677                 {
3678                         uint32_t _flags_save_string = ndr->flags;
3679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3680                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3681                         ndr->flags = _flags_save_string;
3682                 }
3683                 {
3684                         uint32_t _flags_save_string = ndr->flags;
3685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3686                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3687                         ndr->flags = _flags_save_string;
3688                 }
3689                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3690                 {
3691                         uint32_t _flags_save_string = ndr->flags;
3692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3693                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3694                         ndr->flags = _flags_save_string;
3695                 }
3696                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3697                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3704                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3708         }
3709         if (ndr_flags & NDR_BUFFERS) {
3710                 {
3711                         uint32_t _flags_save_string = ndr->flags;
3712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3713                         if (r->printer_name) {
3714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3716                         }
3717                         ndr->flags = _flags_save_string;
3718                 }
3719                 {
3720                         uint32_t _flags_save_string = ndr->flags;
3721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3722                         if (r->server_name) {
3723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3725                         }
3726                         ndr->flags = _flags_save_string;
3727                 }
3728                 {
3729                         uint32_t _flags_save_string = ndr->flags;
3730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3731                         if (r->user_name) {
3732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3734                         }
3735                         ndr->flags = _flags_save_string;
3736                 }
3737                 {
3738                         uint32_t _flags_save_string = ndr->flags;
3739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3740                         if (r->document_name) {
3741                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3742                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3743                         }
3744                         ndr->flags = _flags_save_string;
3745                 }
3746                 {
3747                         uint32_t _flags_save_string = ndr->flags;
3748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3749                         if (r->notify_name) {
3750                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3751                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3752                         }
3753                         ndr->flags = _flags_save_string;
3754                 }
3755                 {
3756                         uint32_t _flags_save_string = ndr->flags;
3757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3758                         if (r->data_type) {
3759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3760                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3761                         }
3762                         ndr->flags = _flags_save_string;
3763                 }
3764                 {
3765                         uint32_t _flags_save_string = ndr->flags;
3766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3767                         if (r->print_processor) {
3768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3770                         }
3771                         ndr->flags = _flags_save_string;
3772                 }
3773                 {
3774                         uint32_t _flags_save_string = ndr->flags;
3775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3776                         if (r->parameters) {
3777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3779                         }
3780                         ndr->flags = _flags_save_string;
3781                 }
3782                 {
3783                         uint32_t _flags_save_string = ndr->flags;
3784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3785                         if (r->driver_name) {
3786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3788                         }
3789                         ndr->flags = _flags_save_string;
3790                 }
3791                 if (r->devmode) {
3792                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3793                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3794                 }
3795                 {
3796                         uint32_t _flags_save_string = ndr->flags;
3797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3798                         if (r->text_status) {
3799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3801                         }
3802                         ndr->flags = _flags_save_string;
3803                 }
3804                 if (r->secdesc) {
3805                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3806                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3807                 }
3808         }
3809         return NDR_ERR_SUCCESS;
3810 }
3811
3812 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3813 {
3814         uint32_t _ptr_printer_name;
3815         TALLOC_CTX *_mem_save_printer_name_0;
3816         uint32_t _ptr_server_name;
3817         TALLOC_CTX *_mem_save_server_name_0;
3818         uint32_t _ptr_user_name;
3819         TALLOC_CTX *_mem_save_user_name_0;
3820         uint32_t _ptr_document_name;
3821         TALLOC_CTX *_mem_save_document_name_0;
3822         uint32_t _ptr_notify_name;
3823         TALLOC_CTX *_mem_save_notify_name_0;
3824         uint32_t _ptr_data_type;
3825         TALLOC_CTX *_mem_save_data_type_0;
3826         uint32_t _ptr_print_processor;
3827         TALLOC_CTX *_mem_save_print_processor_0;
3828         uint32_t _ptr_parameters;
3829         TALLOC_CTX *_mem_save_parameters_0;
3830         uint32_t _ptr_driver_name;
3831         TALLOC_CTX *_mem_save_driver_name_0;
3832         uint32_t _ptr_devmode;
3833         TALLOC_CTX *_mem_save_devmode_0;
3834         uint32_t _ptr_text_status;
3835         TALLOC_CTX *_mem_save_text_status_0;
3836         uint32_t _ptr_secdesc;
3837         TALLOC_CTX *_mem_save_secdesc_0;
3838         if (ndr_flags & NDR_SCALARS) {
3839                 NDR_CHECK(ndr_pull_align(ndr, 4));
3840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3841                 {
3842                         uint32_t _flags_save_string = ndr->flags;
3843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3844                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3845                         if (_ptr_printer_name) {
3846                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3847                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3848                         } else {
3849                                 r->printer_name = NULL;
3850                         }
3851                         ndr->flags = _flags_save_string;
3852                 }
3853                 {
3854                         uint32_t _flags_save_string = ndr->flags;
3855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3856                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3857                         if (_ptr_server_name) {
3858                                 NDR_PULL_ALLOC(ndr, r->server_name);
3859                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3860                         } else {
3861                                 r->server_name = NULL;
3862                         }
3863                         ndr->flags = _flags_save_string;
3864                 }
3865                 {
3866                         uint32_t _flags_save_string = ndr->flags;
3867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3868                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3869                         if (_ptr_user_name) {
3870                                 NDR_PULL_ALLOC(ndr, r->user_name);
3871                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3872                         } else {
3873                                 r->user_name = NULL;
3874                         }
3875                         ndr->flags = _flags_save_string;
3876                 }
3877                 {
3878                         uint32_t _flags_save_string = ndr->flags;
3879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3880                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3881                         if (_ptr_document_name) {
3882                                 NDR_PULL_ALLOC(ndr, r->document_name);
3883                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3884                         } else {
3885                                 r->document_name = NULL;
3886                         }
3887                         ndr->flags = _flags_save_string;
3888                 }
3889                 {
3890                         uint32_t _flags_save_string = ndr->flags;
3891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3892                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3893                         if (_ptr_notify_name) {
3894                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3895                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3896                         } else {
3897                                 r->notify_name = NULL;
3898                         }
3899                         ndr->flags = _flags_save_string;
3900                 }
3901                 {
3902                         uint32_t _flags_save_string = ndr->flags;
3903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3905                         if (_ptr_data_type) {
3906                                 NDR_PULL_ALLOC(ndr, r->data_type);
3907                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3908                         } else {
3909                                 r->data_type = NULL;
3910                         }
3911                         ndr->flags = _flags_save_string;
3912                 }
3913                 {
3914                         uint32_t _flags_save_string = ndr->flags;
3915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3916                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3917                         if (_ptr_print_processor) {
3918                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3919                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3920                         } else {
3921                                 r->print_processor = NULL;
3922                         }
3923                         ndr->flags = _flags_save_string;
3924                 }
3925                 {
3926                         uint32_t _flags_save_string = ndr->flags;
3927                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3928                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3929                         if (_ptr_parameters) {
3930                                 NDR_PULL_ALLOC(ndr, r->parameters);
3931                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3932                         } else {
3933                                 r->parameters = NULL;
3934                         }
3935                         ndr->flags = _flags_save_string;
3936                 }
3937                 {
3938                         uint32_t _flags_save_string = ndr->flags;
3939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3940                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3941                         if (_ptr_driver_name) {
3942                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3943                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3944                         } else {
3945                                 r->driver_name = NULL;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3950                 if (_ptr_devmode) {
3951                         NDR_PULL_ALLOC(ndr, r->devmode);
3952                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3953                 } else {
3954                         r->devmode = NULL;
3955                 }
3956                 {
3957                         uint32_t _flags_save_string = ndr->flags;
3958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3959                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3960                         if (_ptr_text_status) {
3961                                 NDR_PULL_ALLOC(ndr, r->text_status);
3962                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3963                         } else {
3964                                 r->text_status = NULL;
3965                         }
3966                         ndr->flags = _flags_save_string;
3967                 }
3968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3969                 if (_ptr_secdesc) {
3970                         NDR_PULL_ALLOC(ndr, r->secdesc);
3971                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3972                 } else {
3973                         r->secdesc = NULL;
3974                 }
3975                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3977                 if (r->priority > 99) {
3978                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3979                 }
3980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3985                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3989         }
3990         if (ndr_flags & NDR_BUFFERS) {
3991                 {
3992                         uint32_t _flags_save_string = ndr->flags;
3993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3994                         if (r->printer_name) {
3995                                 uint32_t _relative_save_offset;
3996                                 _relative_save_offset = ndr->offset;
3997                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3998                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3999                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4000                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4001                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4002                                 ndr->offset = _relative_save_offset;
4003                         }
4004                         ndr->flags = _flags_save_string;
4005                 }
4006                 {
4007                         uint32_t _flags_save_string = ndr->flags;
4008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4009                         if (r->server_name) {
4010                                 uint32_t _relative_save_offset;
4011                                 _relative_save_offset = ndr->offset;
4012                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4013                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4014                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4015                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4016                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4017                                 ndr->offset = _relative_save_offset;
4018                         }
4019                         ndr->flags = _flags_save_string;
4020                 }
4021                 {
4022                         uint32_t _flags_save_string = ndr->flags;
4023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4024                         if (r->user_name) {
4025                                 uint32_t _relative_save_offset;
4026                                 _relative_save_offset = ndr->offset;
4027                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4028                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4029                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4030                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4031                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4032                                 ndr->offset = _relative_save_offset;
4033                         }
4034                         ndr->flags = _flags_save_string;
4035                 }
4036                 {
4037                         uint32_t _flags_save_string = ndr->flags;
4038                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4039                         if (r->document_name) {
4040                                 uint32_t _relative_save_offset;
4041                                 _relative_save_offset = ndr->offset;
4042                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4043                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4044                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4045                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4046                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4047                                 ndr->offset = _relative_save_offset;
4048                         }
4049                         ndr->flags = _flags_save_string;
4050                 }
4051                 {
4052                         uint32_t _flags_save_string = ndr->flags;
4053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4054                         if (r->notify_name) {
4055                                 uint32_t _relative_save_offset;
4056                                 _relative_save_offset = ndr->offset;
4057                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4058                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4059                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4060                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4061                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4062                                 ndr->offset = _relative_save_offset;
4063                         }
4064                         ndr->flags = _flags_save_string;
4065                 }
4066                 {
4067                         uint32_t _flags_save_string = ndr->flags;
4068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4069                         if (r->data_type) {
4070                                 uint32_t _relative_save_offset;
4071                                 _relative_save_offset = ndr->offset;
4072                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4073                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4074                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4075                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4076                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4077                                 ndr->offset = _relative_save_offset;
4078                         }
4079                         ndr->flags = _flags_save_string;
4080                 }
4081                 {
4082                         uint32_t _flags_save_string = ndr->flags;
4083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4084                         if (r->print_processor) {
4085                                 uint32_t _relative_save_offset;
4086                                 _relative_save_offset = ndr->offset;
4087                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4088                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4089                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4090                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4091                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4092                                 ndr->offset = _relative_save_offset;
4093                         }
4094                         ndr->flags = _flags_save_string;
4095                 }
4096                 {
4097                         uint32_t _flags_save_string = ndr->flags;
4098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4099                         if (r->parameters) {
4100                                 uint32_t _relative_save_offset;
4101                                 _relative_save_offset = ndr->offset;
4102                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4103                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4104                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4105                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4106                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4107                                 ndr->offset = _relative_save_offset;
4108                         }
4109                         ndr->flags = _flags_save_string;
4110                 }
4111                 {
4112                         uint32_t _flags_save_string = ndr->flags;
4113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4114                         if (r->driver_name) {
4115                                 uint32_t _relative_save_offset;
4116                                 _relative_save_offset = ndr->offset;
4117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4118                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4119                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4120                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4122                                 ndr->offset = _relative_save_offset;
4123                         }
4124                         ndr->flags = _flags_save_string;
4125                 }
4126                 if (r->devmode) {
4127                         uint32_t _relative_save_offset;
4128                         _relative_save_offset = ndr->offset;
4129                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4130                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4131                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4132                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4134                         ndr->offset = _relative_save_offset;
4135                 }
4136                 {
4137                         uint32_t _flags_save_string = ndr->flags;
4138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4139                         if (r->text_status) {
4140                                 uint32_t _relative_save_offset;
4141                                 _relative_save_offset = ndr->offset;
4142                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4143                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4144                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4145                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4146                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4147                                 ndr->offset = _relative_save_offset;
4148                         }
4149                         ndr->flags = _flags_save_string;
4150                 }
4151                 if (r->secdesc) {
4152                         uint32_t _relative_save_offset;
4153                         _relative_save_offset = ndr->offset;
4154                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4155                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4156                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4157                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4159                         ndr->offset = _relative_save_offset;
4160                 }
4161         }
4162         return NDR_ERR_SUCCESS;
4163 }
4164
4165 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4166 {
4167         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4168         ndr->depth++;
4169         ndr_print_uint32(ndr, "job_id", r->job_id);
4170         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4171         ndr->depth++;
4172         if (r->printer_name) {
4173                 ndr_print_string(ndr, "printer_name", r->printer_name);
4174         }
4175         ndr->depth--;
4176         ndr_print_ptr(ndr, "server_name", r->server_name);
4177         ndr->depth++;
4178         if (r->server_name) {
4179                 ndr_print_string(ndr, "server_name", r->server_name);
4180         }
4181         ndr->depth--;
4182         ndr_print_ptr(ndr, "user_name", r->user_name);
4183         ndr->depth++;
4184         if (r->user_name) {
4185                 ndr_print_string(ndr, "user_name", r->user_name);
4186         }
4187         ndr->depth--;
4188         ndr_print_ptr(ndr, "document_name", r->document_name);
4189         ndr->depth++;
4190         if (r->document_name) {
4191                 ndr_print_string(ndr, "document_name", r->document_name);
4192         }
4193         ndr->depth--;
4194         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4195         ndr->depth++;
4196         if (r->notify_name) {
4197                 ndr_print_string(ndr, "notify_name", r->notify_name);
4198         }
4199         ndr->depth--;
4200         ndr_print_ptr(ndr, "data_type", r->data_type);
4201         ndr->depth++;
4202         if (r->data_type) {
4203                 ndr_print_string(ndr, "data_type", r->data_type);
4204         }
4205         ndr->depth--;
4206         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4207         ndr->depth++;
4208         if (r->print_processor) {
4209                 ndr_print_string(ndr, "print_processor", r->print_processor);
4210         }
4211         ndr->depth--;
4212         ndr_print_ptr(ndr, "parameters", r->parameters);
4213         ndr->depth++;
4214         if (r->parameters) {
4215                 ndr_print_string(ndr, "parameters", r->parameters);
4216         }
4217         ndr->depth--;
4218         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4219         ndr->depth++;
4220         if (r->driver_name) {
4221                 ndr_print_string(ndr, "driver_name", r->driver_name);
4222         }
4223         ndr->depth--;
4224         ndr_print_ptr(ndr, "devmode", r->devmode);
4225         ndr->depth++;
4226         if (r->devmode) {
4227                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4228         }
4229         ndr->depth--;
4230         ndr_print_ptr(ndr, "text_status", r->text_status);
4231         ndr->depth++;
4232         if (r->text_status) {
4233                 ndr_print_string(ndr, "text_status", r->text_status);
4234         }
4235         ndr->depth--;
4236         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4237         ndr->depth++;
4238         if (r->secdesc) {
4239                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4240         }
4241         ndr->depth--;
4242         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4243         ndr_print_uint32(ndr, "priority", r->priority);
4244         ndr_print_uint32(ndr, "position", r->position);
4245         ndr_print_uint32(ndr, "start_time", r->start_time);
4246         ndr_print_uint32(ndr, "until_time", r->until_time);
4247         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4248         ndr_print_uint32(ndr, "size", r->size);
4249         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4250         ndr_print_uint32(ndr, "time", r->time);
4251         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4252         ndr_print_uint32(ndr, "size_high", r->size_high);
4253         ndr->depth--;
4254 }
4255
4256 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4257 {
4258         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4259 }
4260
4261 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4262 {
4263         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4264         if (ndr_flags & NDR_SCALARS) {
4265                 int level = ndr_push_get_switch_value(ndr, r);
4266                 switch (level) {
4267                         case 1: {
4268                                 NDR_CHECK(ndr_push_align(ndr, 4));
4269                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4270                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4271                         break; }
4272
4273                         case 2: {
4274                                 NDR_CHECK(ndr_push_align(ndr, 4));
4275                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4276                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4277                         break; }
4278
4279                         case 3: {
4280                                 NDR_CHECK(ndr_push_align(ndr, 4));
4281                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4282                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4283                         break; }
4284
4285                         case 4: {
4286                                 NDR_CHECK(ndr_push_align(ndr, 4));
4287                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4288                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4289                         break; }
4290
4291                         default: {
4292                         break; }
4293
4294                 }
4295         }
4296         if (ndr_flags & NDR_BUFFERS) {
4297                 int level = ndr_push_get_switch_value(ndr, r);
4298                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4299                 switch (level) {
4300                         case 1:
4301                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4302                         break;
4303
4304                         case 2:
4305                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4306                         break;
4307
4308                         case 3:
4309                         break;
4310
4311                         case 4:
4312                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4313                         break;
4314
4315                         default:
4316                         break;
4317
4318                 }
4319         }
4320         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4321         return NDR_ERR_SUCCESS;
4322 }
4323
4324 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4325 {
4326         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4327         int level;
4328         level = ndr_pull_get_switch_value(ndr, r);
4329         if (ndr_flags & NDR_SCALARS) {
4330                 switch (level) {
4331                         case 1: {
4332                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4333                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4334                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4335                         break; }
4336
4337                         case 2: {
4338                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4339                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4340                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4341                         break; }
4342
4343                         case 3: {
4344                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4345                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4346                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4347                         break; }
4348
4349                         case 4: {
4350                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4351                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4352                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4353                         break; }
4354
4355                         default: {
4356                         break; }
4357
4358                 }
4359         }
4360         if (ndr_flags & NDR_BUFFERS) {
4361                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4362                 switch (level) {
4363                         case 1:
4364                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4365                         break;
4366
4367                         case 2:
4368                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4369                         break;
4370
4371                         case 3:
4372                         break;
4373
4374                         case 4:
4375                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4376                         break;
4377
4378                         default:
4379                         break;
4380
4381                 }
4382         }
4383         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4384         return NDR_ERR_SUCCESS;
4385 }
4386
4387 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4388 {
4389         int level;
4390         level = ndr_print_get_switch_value(ndr, r);
4391         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4392         switch (level) {
4393                 case 1:
4394                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4395                 break;
4396
4397                 case 2:
4398                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4399                 break;
4400
4401                 case 3:
4402                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4403                 break;
4404
4405                 case 4:
4406                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4407                 break;
4408
4409                 default:
4410                 break;
4411
4412         }
4413 }
4414
4415 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4416 {
4417         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4418 }
4419
4420 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4421 {
4422         if (ndr_flags & NDR_SCALARS) {
4423                 NDR_CHECK(ndr_push_align(ndr, 4));
4424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4427                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4431                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4436                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4437         }
4438         if (ndr_flags & NDR_BUFFERS) {
4439                 if (r->printer_name) {
4440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4444                 }
4445                 if (r->server_name) {
4446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4449                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4450                 }
4451                 if (r->user_name) {
4452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4456                 }
4457                 if (r->document_name) {
4458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4462                 }
4463                 if (r->data_type) {
4464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4467                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4468                 }
4469                 if (r->text_status) {
4470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4473                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4474                 }
4475         }
4476         return NDR_ERR_SUCCESS;
4477 }
4478
4479 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4480 {
4481         uint32_t _ptr_printer_name;
4482         TALLOC_CTX *_mem_save_printer_name_0;
4483         uint32_t _ptr_server_name;
4484         TALLOC_CTX *_mem_save_server_name_0;
4485         uint32_t _ptr_user_name;
4486         TALLOC_CTX *_mem_save_user_name_0;
4487         uint32_t _ptr_document_name;
4488         TALLOC_CTX *_mem_save_document_name_0;
4489         uint32_t _ptr_data_type;
4490         TALLOC_CTX *_mem_save_data_type_0;
4491         uint32_t _ptr_text_status;
4492         TALLOC_CTX *_mem_save_text_status_0;
4493         if (ndr_flags & NDR_SCALARS) {
4494                 NDR_CHECK(ndr_pull_align(ndr, 4));
4495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4497                 if (_ptr_printer_name) {
4498                         NDR_PULL_ALLOC(ndr, r->printer_name);
4499                 } else {
4500                         r->printer_name = NULL;
4501                 }
4502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4503                 if (_ptr_server_name) {
4504                         NDR_PULL_ALLOC(ndr, r->server_name);
4505                 } else {
4506                         r->server_name = NULL;
4507                 }
4508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4509                 if (_ptr_user_name) {
4510                         NDR_PULL_ALLOC(ndr, r->user_name);
4511                 } else {
4512                         r->user_name = NULL;
4513                 }
4514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4515                 if (_ptr_document_name) {
4516                         NDR_PULL_ALLOC(ndr, r->document_name);
4517                 } else {
4518                         r->document_name = NULL;
4519                 }
4520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4521                 if (_ptr_data_type) {
4522                         NDR_PULL_ALLOC(ndr, r->data_type);
4523                 } else {
4524                         r->data_type = NULL;
4525                 }
4526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4527                 if (_ptr_text_status) {
4528                         NDR_PULL_ALLOC(ndr, r->text_status);
4529                 } else {
4530                         r->text_status = NULL;
4531                 }
4532                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4534                 if (r->priority > 99) {
4535                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4536                 }
4537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4540                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4541         }
4542         if (ndr_flags & NDR_BUFFERS) {
4543                 if (r->printer_name) {
4544                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4545                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4546                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4547                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4548                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4549                                 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));
4550                         }
4551                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4552                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4554                 }
4555                 if (r->server_name) {
4556                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4557                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4558                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4559                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4560                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4561                                 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));
4562                         }
4563                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4564                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4566                 }
4567                 if (r->user_name) {
4568                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4569                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4572                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4573                                 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));
4574                         }
4575                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4578                 }
4579                 if (r->document_name) {
4580                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4581                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4582                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4583                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4584                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4585                                 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));
4586                         }
4587                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4588                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4590                 }
4591                 if (r->data_type) {
4592                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4593                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4596                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4597                                 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));
4598                         }
4599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4602                 }
4603                 if (r->text_status) {
4604                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4605                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4606                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4607                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4608                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4609                                 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));
4610                         }
4611                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4612                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4614                 }
4615         }
4616         return NDR_ERR_SUCCESS;
4617 }
4618
4619 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4620 {
4621         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4622         ndr->depth++;
4623         ndr_print_uint32(ndr, "job_id", r->job_id);
4624         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4625         ndr->depth++;
4626         if (r->printer_name) {
4627                 ndr_print_string(ndr, "printer_name", r->printer_name);
4628         }
4629         ndr->depth--;
4630         ndr_print_ptr(ndr, "server_name", r->server_name);
4631         ndr->depth++;
4632         if (r->server_name) {
4633                 ndr_print_string(ndr, "server_name", r->server_name);
4634         }
4635         ndr->depth--;
4636         ndr_print_ptr(ndr, "user_name", r->user_name);
4637         ndr->depth++;
4638         if (r->user_name) {
4639                 ndr_print_string(ndr, "user_name", r->user_name);
4640         }
4641         ndr->depth--;
4642         ndr_print_ptr(ndr, "document_name", r->document_name);
4643         ndr->depth++;
4644         if (r->document_name) {
4645                 ndr_print_string(ndr, "document_name", r->document_name);
4646         }
4647         ndr->depth--;
4648         ndr_print_ptr(ndr, "data_type", r->data_type);
4649         ndr->depth++;
4650         if (r->data_type) {
4651                 ndr_print_string(ndr, "data_type", r->data_type);
4652         }
4653         ndr->depth--;
4654         ndr_print_ptr(ndr, "text_status", r->text_status);
4655         ndr->depth++;
4656         if (r->text_status) {
4657                 ndr_print_string(ndr, "text_status", r->text_status);
4658         }
4659         ndr->depth--;
4660         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4661         ndr_print_uint32(ndr, "priority", r->priority);
4662         ndr_print_uint32(ndr, "position", r->position);
4663         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4664         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4665         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4666         ndr->depth--;
4667 }
4668
4669 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4670 {
4671         if (ndr_flags & NDR_SCALARS) {
4672                 NDR_CHECK(ndr_push_align(ndr, 4));
4673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4682                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4686                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4693                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4696         }
4697         if (ndr_flags & NDR_BUFFERS) {
4698                 if (r->printer_name) {
4699                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4700                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4702                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4703                 }
4704                 if (r->server_name) {
4705                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4708                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4709                 }
4710                 if (r->user_name) {
4711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4714                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4715                 }
4716                 if (r->document_name) {
4717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4720                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4721                 }
4722                 if (r->notify_name) {
4723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4727                 }
4728                 if (r->data_type) {
4729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4732                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4733                 }
4734                 if (r->print_processor) {
4735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4739                 }
4740                 if (r->parameters) {
4741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4744                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4745                 }
4746                 if (r->driver_name) {
4747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4751                 }
4752                 if (r->text_status) {
4753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4756                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4757                 }
4758         }
4759         return NDR_ERR_SUCCESS;
4760 }
4761
4762 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4763 {
4764         uint32_t _ptr_printer_name;
4765         TALLOC_CTX *_mem_save_printer_name_0;
4766         uint32_t _ptr_server_name;
4767         TALLOC_CTX *_mem_save_server_name_0;
4768         uint32_t _ptr_user_name;
4769         TALLOC_CTX *_mem_save_user_name_0;
4770         uint32_t _ptr_document_name;
4771         TALLOC_CTX *_mem_save_document_name_0;
4772         uint32_t _ptr_notify_name;
4773         TALLOC_CTX *_mem_save_notify_name_0;
4774         uint32_t _ptr_data_type;
4775         TALLOC_CTX *_mem_save_data_type_0;
4776         uint32_t _ptr_print_processor;
4777         TALLOC_CTX *_mem_save_print_processor_0;
4778         uint32_t _ptr_parameters;
4779         TALLOC_CTX *_mem_save_parameters_0;
4780         uint32_t _ptr_driver_name;
4781         TALLOC_CTX *_mem_save_driver_name_0;
4782         uint32_t _ptr_text_status;
4783         TALLOC_CTX *_mem_save_text_status_0;
4784         if (ndr_flags & NDR_SCALARS) {
4785                 NDR_CHECK(ndr_pull_align(ndr, 4));
4786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4787                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4788                 if (_ptr_printer_name) {
4789                         NDR_PULL_ALLOC(ndr, r->printer_name);
4790                 } else {
4791                         r->printer_name = NULL;
4792                 }
4793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4794                 if (_ptr_server_name) {
4795                         NDR_PULL_ALLOC(ndr, r->server_name);
4796                 } else {
4797                         r->server_name = NULL;
4798                 }
4799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4800                 if (_ptr_user_name) {
4801                         NDR_PULL_ALLOC(ndr, r->user_name);
4802                 } else {
4803                         r->user_name = NULL;
4804                 }
4805                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4806                 if (_ptr_document_name) {
4807                         NDR_PULL_ALLOC(ndr, r->document_name);
4808                 } else {
4809                         r->document_name = NULL;
4810                 }
4811                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4812                 if (_ptr_notify_name) {
4813                         NDR_PULL_ALLOC(ndr, r->notify_name);
4814                 } else {
4815                         r->notify_name = NULL;
4816                 }
4817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4818                 if (_ptr_data_type) {
4819                         NDR_PULL_ALLOC(ndr, r->data_type);
4820                 } else {
4821                         r->data_type = NULL;
4822                 }
4823                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4824                 if (_ptr_print_processor) {
4825                         NDR_PULL_ALLOC(ndr, r->print_processor);
4826                 } else {
4827                         r->print_processor = NULL;
4828                 }
4829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4830                 if (_ptr_parameters) {
4831                         NDR_PULL_ALLOC(ndr, r->parameters);
4832                 } else {
4833                         r->parameters = NULL;
4834                 }
4835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4836                 if (_ptr_driver_name) {
4837                         NDR_PULL_ALLOC(ndr, r->driver_name);
4838                 } else {
4839                         r->driver_name = NULL;
4840                 }
4841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4843                 if (_ptr_text_status) {
4844                         NDR_PULL_ALLOC(ndr, r->text_status);
4845                 } else {
4846                         r->text_status = NULL;
4847                 }
4848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4849                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4851                 if (r->priority > 99) {
4852                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4853                 }
4854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4859                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4862         }
4863         if (ndr_flags & NDR_BUFFERS) {
4864                 if (r->printer_name) {
4865                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4866                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4868                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4869                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4870                                 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));
4871                         }
4872                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4873                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4875                 }
4876                 if (r->server_name) {
4877                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4878                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4879                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4880                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4881                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4882                                 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));
4883                         }
4884                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4885                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4886                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4887                 }
4888                 if (r->user_name) {
4889                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4890                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4891                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4892                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4893                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4894                                 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));
4895                         }
4896                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4897                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4899                 }
4900                 if (r->document_name) {
4901                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4902                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4903                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4904                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4905                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4906                                 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));
4907                         }
4908                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4909                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4910                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4911                 }
4912                 if (r->notify_name) {
4913                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4914                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4915                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4916                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4917                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4918                                 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));
4919                         }
4920                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4921                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4923                 }
4924                 if (r->data_type) {
4925                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4926                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4929                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4930                                 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));
4931                         }
4932                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4933                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4935                 }
4936                 if (r->print_processor) {
4937                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4938                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4940                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4941                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4942                                 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));
4943                         }
4944                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4945                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4947                 }
4948                 if (r->parameters) {
4949                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4950                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4951                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4952                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4953                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4954                                 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));
4955                         }
4956                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4957                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4959                 }
4960                 if (r->driver_name) {
4961                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4962                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4965                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4966                                 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));
4967                         }
4968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4969                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4971                 }
4972                 if (r->text_status) {
4973                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4974                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4976                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4977                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4978                                 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));
4979                         }
4980                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4983                 }
4984         }
4985         return NDR_ERR_SUCCESS;
4986 }
4987
4988 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4989 {
4990         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4991         ndr->depth++;
4992         ndr_print_uint32(ndr, "job_id", r->job_id);
4993         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4994         ndr->depth++;
4995         if (r->printer_name) {
4996                 ndr_print_string(ndr, "printer_name", r->printer_name);
4997         }
4998         ndr->depth--;
4999         ndr_print_ptr(ndr, "server_name", r->server_name);
5000         ndr->depth++;
5001         if (r->server_name) {
5002                 ndr_print_string(ndr, "server_name", r->server_name);
5003         }
5004         ndr->depth--;
5005         ndr_print_ptr(ndr, "user_name", r->user_name);
5006         ndr->depth++;
5007         if (r->user_name) {
5008                 ndr_print_string(ndr, "user_name", r->user_name);
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "document_name", r->document_name);
5012         ndr->depth++;
5013         if (r->document_name) {
5014                 ndr_print_string(ndr, "document_name", r->document_name);
5015         }
5016         ndr->depth--;
5017         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5018         ndr->depth++;
5019         if (r->notify_name) {
5020                 ndr_print_string(ndr, "notify_name", r->notify_name);
5021         }
5022         ndr->depth--;
5023         ndr_print_ptr(ndr, "data_type", r->data_type);
5024         ndr->depth++;
5025         if (r->data_type) {
5026                 ndr_print_string(ndr, "data_type", r->data_type);
5027         }
5028         ndr->depth--;
5029         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5030         ndr->depth++;
5031         if (r->print_processor) {
5032                 ndr_print_string(ndr, "print_processor", r->print_processor);
5033         }
5034         ndr->depth--;
5035         ndr_print_ptr(ndr, "parameters", r->parameters);
5036         ndr->depth++;
5037         if (r->parameters) {
5038                 ndr_print_string(ndr, "parameters", r->parameters);
5039         }
5040         ndr->depth--;
5041         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5042         ndr->depth++;
5043         if (r->driver_name) {
5044                 ndr_print_string(ndr, "driver_name", r->driver_name);
5045         }
5046         ndr->depth--;
5047         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5048         ndr_print_ptr(ndr, "text_status", r->text_status);
5049         ndr->depth++;
5050         if (r->text_status) {
5051                 ndr_print_string(ndr, "text_status", r->text_status);
5052         }
5053         ndr->depth--;
5054         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5055         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5056         ndr_print_uint32(ndr, "priority", r->priority);
5057         ndr_print_uint32(ndr, "position", r->position);
5058         ndr_print_uint32(ndr, "start_time", r->start_time);
5059         ndr_print_uint32(ndr, "until_time", r->until_time);
5060         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5061         ndr_print_uint32(ndr, "size", r->size);
5062         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5063         ndr_print_uint32(ndr, "time", r->time);
5064         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5065         ndr->depth--;
5066 }
5067
5068 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5069 {
5070         if (ndr_flags & NDR_SCALARS) {
5071                 NDR_CHECK(ndr_push_align(ndr, 4));
5072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5080                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5083                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5085                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5092                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5096         }
5097         if (ndr_flags & NDR_BUFFERS) {
5098                 if (r->printer_name) {
5099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5103                 }
5104                 if (r->server_name) {
5105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5109                 }
5110                 if (r->user_name) {
5111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5115                 }
5116                 if (r->document_name) {
5117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5121                 }
5122                 if (r->notify_name) {
5123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5127                 }
5128                 if (r->data_type) {
5129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5133                 }
5134                 if (r->print_processor) {
5135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5139                 }
5140                 if (r->parameters) {
5141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5144                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5145                 }
5146                 if (r->driver_name) {
5147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5149                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5150                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5151                 }
5152                 if (r->text_status) {
5153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5156                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5157                 }
5158         }
5159         return NDR_ERR_SUCCESS;
5160 }
5161
5162 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5163 {
5164         uint32_t _ptr_printer_name;
5165         TALLOC_CTX *_mem_save_printer_name_0;
5166         uint32_t _ptr_server_name;
5167         TALLOC_CTX *_mem_save_server_name_0;
5168         uint32_t _ptr_user_name;
5169         TALLOC_CTX *_mem_save_user_name_0;
5170         uint32_t _ptr_document_name;
5171         TALLOC_CTX *_mem_save_document_name_0;
5172         uint32_t _ptr_notify_name;
5173         TALLOC_CTX *_mem_save_notify_name_0;
5174         uint32_t _ptr_data_type;
5175         TALLOC_CTX *_mem_save_data_type_0;
5176         uint32_t _ptr_print_processor;
5177         TALLOC_CTX *_mem_save_print_processor_0;
5178         uint32_t _ptr_parameters;
5179         TALLOC_CTX *_mem_save_parameters_0;
5180         uint32_t _ptr_driver_name;
5181         TALLOC_CTX *_mem_save_driver_name_0;
5182         uint32_t _ptr_text_status;
5183         TALLOC_CTX *_mem_save_text_status_0;
5184         if (ndr_flags & NDR_SCALARS) {
5185                 NDR_CHECK(ndr_pull_align(ndr, 4));
5186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5188                 if (_ptr_printer_name) {
5189                         NDR_PULL_ALLOC(ndr, r->printer_name);
5190                 } else {
5191                         r->printer_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5194                 if (_ptr_server_name) {
5195                         NDR_PULL_ALLOC(ndr, r->server_name);
5196                 } else {
5197                         r->server_name = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5200                 if (_ptr_user_name) {
5201                         NDR_PULL_ALLOC(ndr, r->user_name);
5202                 } else {
5203                         r->user_name = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5206                 if (_ptr_document_name) {
5207                         NDR_PULL_ALLOC(ndr, r->document_name);
5208                 } else {
5209                         r->document_name = NULL;
5210                 }
5211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5212                 if (_ptr_notify_name) {
5213                         NDR_PULL_ALLOC(ndr, r->notify_name);
5214                 } else {
5215                         r->notify_name = NULL;
5216                 }
5217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5218                 if (_ptr_data_type) {
5219                         NDR_PULL_ALLOC(ndr, r->data_type);
5220                 } else {
5221                         r->data_type = NULL;
5222                 }
5223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5224                 if (_ptr_print_processor) {
5225                         NDR_PULL_ALLOC(ndr, r->print_processor);
5226                 } else {
5227                         r->print_processor = NULL;
5228                 }
5229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5230                 if (_ptr_parameters) {
5231                         NDR_PULL_ALLOC(ndr, r->parameters);
5232                 } else {
5233                         r->parameters = NULL;
5234                 }
5235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5236                 if (_ptr_driver_name) {
5237                         NDR_PULL_ALLOC(ndr, r->driver_name);
5238                 } else {
5239                         r->driver_name = NULL;
5240                 }
5241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5243                 if (_ptr_text_status) {
5244                         NDR_PULL_ALLOC(ndr, r->text_status);
5245                 } else {
5246                         r->text_status = NULL;
5247                 }
5248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5249                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5251                 if (r->priority > 99) {
5252                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5253                 }
5254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5259                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5263         }
5264         if (ndr_flags & NDR_BUFFERS) {
5265                 if (r->printer_name) {
5266                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5267                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5270                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5271                                 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));
5272                         }
5273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5276                 }
5277                 if (r->server_name) {
5278                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5279                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5282                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5283                                 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));
5284                         }
5285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5288                 }
5289                 if (r->user_name) {
5290                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5291                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5292                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5293                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5294                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5295                                 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));
5296                         }
5297                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5298                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5300                 }
5301                 if (r->document_name) {
5302                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5303                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5304                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5305                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5306                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5307                                 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));
5308                         }
5309                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5310                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5312                 }
5313                 if (r->notify_name) {
5314                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5315                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5316                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5317                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5318                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5319                                 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));
5320                         }
5321                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5322                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5324                 }
5325                 if (r->data_type) {
5326                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5327                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5329                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5330                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5331                                 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));
5332                         }
5333                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5334                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5336                 }
5337                 if (r->print_processor) {
5338                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5339                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5341                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5342                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
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->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5344                         }
5345                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5346                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5348                 }
5349                 if (r->parameters) {
5350                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5351                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5353                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5354                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
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->parameters), ndr_get_array_length(ndr, &r->parameters));
5356                         }
5357                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5358                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5360                 }
5361                 if (r->driver_name) {
5362                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5363                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5366                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_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->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5368                         }
5369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5372                 }
5373                 if (r->text_status) {
5374                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5375                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5377                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5378                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
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->text_status), ndr_get_array_length(ndr, &r->text_status));
5380                         }
5381                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5382                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5384                 }
5385         }
5386         return NDR_ERR_SUCCESS;
5387 }
5388
5389 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5390 {
5391         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5392         ndr->depth++;
5393         ndr_print_uint32(ndr, "job_id", r->job_id);
5394         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5395         ndr->depth++;
5396         if (r->printer_name) {
5397                 ndr_print_string(ndr, "printer_name", r->printer_name);
5398         }
5399         ndr->depth--;
5400         ndr_print_ptr(ndr, "server_name", r->server_name);
5401         ndr->depth++;
5402         if (r->server_name) {
5403                 ndr_print_string(ndr, "server_name", r->server_name);
5404         }
5405         ndr->depth--;
5406         ndr_print_ptr(ndr, "user_name", r->user_name);
5407         ndr->depth++;
5408         if (r->user_name) {
5409                 ndr_print_string(ndr, "user_name", r->user_name);
5410         }
5411         ndr->depth--;
5412         ndr_print_ptr(ndr, "document_name", r->document_name);
5413         ndr->depth++;
5414         if (r->document_name) {
5415                 ndr_print_string(ndr, "document_name", r->document_name);
5416         }
5417         ndr->depth--;
5418         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5419         ndr->depth++;
5420         if (r->notify_name) {
5421                 ndr_print_string(ndr, "notify_name", r->notify_name);
5422         }
5423         ndr->depth--;
5424         ndr_print_ptr(ndr, "data_type", r->data_type);
5425         ndr->depth++;
5426         if (r->data_type) {
5427                 ndr_print_string(ndr, "data_type", r->data_type);
5428         }
5429         ndr->depth--;
5430         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5431         ndr->depth++;
5432         if (r->print_processor) {
5433                 ndr_print_string(ndr, "print_processor", r->print_processor);
5434         }
5435         ndr->depth--;
5436         ndr_print_ptr(ndr, "parameters", r->parameters);
5437         ndr->depth++;
5438         if (r->parameters) {
5439                 ndr_print_string(ndr, "parameters", r->parameters);
5440         }
5441         ndr->depth--;
5442         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5443         ndr->depth++;
5444         if (r->driver_name) {
5445                 ndr_print_string(ndr, "driver_name", r->driver_name);
5446         }
5447         ndr->depth--;
5448         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5449         ndr_print_ptr(ndr, "text_status", r->text_status);
5450         ndr->depth++;
5451         if (r->text_status) {
5452                 ndr_print_string(ndr, "text_status", r->text_status);
5453         }
5454         ndr->depth--;
5455         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5456         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5457         ndr_print_uint32(ndr, "priority", r->priority);
5458         ndr_print_uint32(ndr, "position", r->position);
5459         ndr_print_uint32(ndr, "start_time", r->start_time);
5460         ndr_print_uint32(ndr, "until_time", r->until_time);
5461         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5462         ndr_print_uint32(ndr, "size", r->size);
5463         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5464         ndr_print_uint32(ndr, "time", r->time);
5465         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5466         ndr_print_uint32(ndr, "size_high", r->size_high);
5467         ndr->depth--;
5468 }
5469
5470 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5471 {
5472         if (ndr_flags & NDR_SCALARS) {
5473                 int level = ndr_push_get_switch_value(ndr, r);
5474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5475                 switch (level) {
5476                         case 1: {
5477                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5478                         break; }
5479
5480                         case 2: {
5481                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5482                         break; }
5483
5484                         case 3: {
5485                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5486                         break; }
5487
5488                         case 4: {
5489                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5490                         break; }
5491
5492                         default: {
5493                         break; }
5494
5495                 }
5496         }
5497         if (ndr_flags & NDR_BUFFERS) {
5498                 int level = ndr_push_get_switch_value(ndr, r);
5499                 switch (level) {
5500                         case 1:
5501                                 if (r->info1) {
5502                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5503                                 }
5504                         break;
5505
5506                         case 2:
5507                                 if (r->info2) {
5508                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5509                                 }
5510                         break;
5511
5512                         case 3:
5513                                 if (r->info3) {
5514                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5515                                 }
5516                         break;
5517
5518                         case 4:
5519                                 if (r->info4) {
5520                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5521                                 }
5522                         break;
5523
5524                         default:
5525                         break;
5526
5527                 }
5528         }
5529         return NDR_ERR_SUCCESS;
5530 }
5531
5532 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5533 {
5534         int level;
5535         uint32_t _level;
5536         TALLOC_CTX *_mem_save_info1_0;
5537         TALLOC_CTX *_mem_save_info2_0;
5538         TALLOC_CTX *_mem_save_info3_0;
5539         TALLOC_CTX *_mem_save_info4_0;
5540         level = ndr_pull_get_switch_value(ndr, r);
5541         if (ndr_flags & NDR_SCALARS) {
5542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5543                 if (_level != level) {
5544                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5545                 }
5546                 switch (level) {
5547                         case 1: {
5548                                 uint32_t _ptr_info1;
5549                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5550                                 if (_ptr_info1) {
5551                                         NDR_PULL_ALLOC(ndr, r->info1);
5552                                 } else {
5553                                         r->info1 = NULL;
5554                                 }
5555                         break; }
5556
5557                         case 2: {
5558                                 uint32_t _ptr_info2;
5559                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5560                                 if (_ptr_info2) {
5561                                         NDR_PULL_ALLOC(ndr, r->info2);
5562                                 } else {
5563                                         r->info2 = NULL;
5564                                 }
5565                         break; }
5566
5567                         case 3: {
5568                                 uint32_t _ptr_info3;
5569                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5570                                 if (_ptr_info3) {
5571                                         NDR_PULL_ALLOC(ndr, r->info3);
5572                                 } else {
5573                                         r->info3 = NULL;
5574                                 }
5575                         break; }
5576
5577                         case 4: {
5578                                 uint32_t _ptr_info4;
5579                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5580                                 if (_ptr_info4) {
5581                                         NDR_PULL_ALLOC(ndr, r->info4);
5582                                 } else {
5583                                         r->info4 = NULL;
5584                                 }
5585                         break; }
5586
5587                         default: {
5588                         break; }
5589
5590                 }
5591         }
5592         if (ndr_flags & NDR_BUFFERS) {
5593                 switch (level) {
5594                         case 1:
5595                                 if (r->info1) {
5596                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5597                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5598                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5599                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5600                                 }
5601                         break;
5602
5603                         case 2:
5604                                 if (r->info2) {
5605                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5606                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5607                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5608                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5609                                 }
5610                         break;
5611
5612                         case 3:
5613                                 if (r->info3) {
5614                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5615                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5616                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5617                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5618                                 }
5619                         break;
5620
5621                         case 4:
5622                                 if (r->info4) {
5623                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5624                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5625                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5626                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5627                                 }
5628                         break;
5629
5630                         default:
5631                         break;
5632
5633                 }
5634         }
5635         return NDR_ERR_SUCCESS;
5636 }
5637
5638 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5639 {
5640         int level;
5641         level = ndr_print_get_switch_value(ndr, r);
5642         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5643         switch (level) {
5644                 case 1:
5645                         ndr_print_ptr(ndr, "info1", r->info1);
5646                         ndr->depth++;
5647                         if (r->info1) {
5648                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5649                         }
5650                         ndr->depth--;
5651                 break;
5652
5653                 case 2:
5654                         ndr_print_ptr(ndr, "info2", r->info2);
5655                         ndr->depth++;
5656                         if (r->info2) {
5657                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5658                         }
5659                         ndr->depth--;
5660                 break;
5661
5662                 case 3:
5663                         ndr_print_ptr(ndr, "info3", r->info3);
5664                         ndr->depth++;
5665                         if (r->info3) {
5666                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5667                         }
5668                         ndr->depth--;
5669                 break;
5670
5671                 case 4:
5672                         ndr_print_ptr(ndr, "info4", r->info4);
5673                         ndr->depth++;
5674                         if (r->info4) {
5675                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5676                         }
5677                         ndr->depth--;
5678                 break;
5679
5680                 default:
5681                 break;
5682
5683         }
5684 }
5685
5686 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5687 {
5688         if (ndr_flags & NDR_SCALARS) {
5689                 NDR_CHECK(ndr_push_align(ndr, 4));
5690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5691                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5692                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5693         }
5694         if (ndr_flags & NDR_BUFFERS) {
5695                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5696         }
5697         return NDR_ERR_SUCCESS;
5698 }
5699
5700 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5701 {
5702         if (ndr_flags & NDR_SCALARS) {
5703                 NDR_CHECK(ndr_pull_align(ndr, 4));
5704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5705                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5706                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5707         }
5708         if (ndr_flags & NDR_BUFFERS) {
5709                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5710         }
5711         return NDR_ERR_SUCCESS;
5712 }
5713
5714 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5715 {
5716         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5717         ndr->depth++;
5718         ndr_print_uint32(ndr, "level", r->level);
5719         ndr_print_set_switch_value(ndr, &r->info, r->level);
5720         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5721         ndr->depth--;
5722 }
5723
5724 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5725 {
5726         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5727         return NDR_ERR_SUCCESS;
5728 }
5729
5730 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5731 {
5732         uint32_t v;
5733         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5734         *r = v;
5735         return NDR_ERR_SUCCESS;
5736 }
5737
5738 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5739 {
5740         const char *val = NULL;
5741
5742         switch (r) {
5743                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5744                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5745                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5746                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5747                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5748                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5749                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5750                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5751                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5752         }
5753         ndr_print_enum(ndr, name, "ENUM", val, r);
5754 }
5755
5756 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5757 {
5758         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5759         return NDR_ERR_SUCCESS;
5760 }
5761
5762 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5763 {
5764         uint32_t v;
5765         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5766         *r = v;
5767         return NDR_ERR_SUCCESS;
5768 }
5769
5770 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5771 {
5772         const char *val = NULL;
5773
5774         switch (r) {
5775                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5776                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5777                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5778                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5779                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5780         }
5781         ndr_print_enum(ndr, name, "ENUM", val, r);
5782 }
5783
5784 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5785 {
5786         if (ndr_flags & NDR_SCALARS) {
5787                 NDR_CHECK(ndr_push_align(ndr, 4));
5788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5793                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5805                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5808                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5812                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5813                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5817         }
5818         if (ndr_flags & NDR_BUFFERS) {
5819                 if (r->servername) {
5820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5824                 }
5825                 if (r->printername) {
5826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5830                 }
5831         }
5832         return NDR_ERR_SUCCESS;
5833 }
5834
5835 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5836 {
5837         uint32_t _ptr_servername;
5838         TALLOC_CTX *_mem_save_servername_0;
5839         uint32_t _ptr_printername;
5840         TALLOC_CTX *_mem_save_printername_0;
5841         if (ndr_flags & NDR_SCALARS) {
5842                 NDR_CHECK(ndr_pull_align(ndr, 4));
5843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5844                 if (_ptr_servername) {
5845                         NDR_PULL_ALLOC(ndr, r->servername);
5846                 } else {
5847                         r->servername = NULL;
5848                 }
5849                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5850                 if (_ptr_printername) {
5851                         NDR_PULL_ALLOC(ndr, r->printername);
5852                 } else {
5853                         r->printername = NULL;
5854                 }
5855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5858                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5870                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5873                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5877                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5878                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5882         }
5883         if (ndr_flags & NDR_BUFFERS) {
5884                 if (r->servername) {
5885                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5886                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5887                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5888                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5889                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5890                                 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));
5891                         }
5892                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5893                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5895                 }
5896                 if (r->printername) {
5897                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5898                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5899                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5900                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5901                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5902                                 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));
5903                         }
5904                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5905                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5907                 }
5908         }
5909         return NDR_ERR_SUCCESS;
5910 }
5911
5912 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5913 {
5914         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5915         ndr->depth++;
5916         ndr_print_ptr(ndr, "servername", r->servername);
5917         ndr->depth++;
5918         if (r->servername) {
5919                 ndr_print_string(ndr, "servername", r->servername);
5920         }
5921         ndr->depth--;
5922         ndr_print_ptr(ndr, "printername", r->printername);
5923         ndr->depth++;
5924         if (r->printername) {
5925                 ndr_print_string(ndr, "printername", r->printername);
5926         }
5927         ndr->depth--;
5928         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5929         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5930         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5931         ndr_print_spoolss_Time(ndr, "time", &r->time);
5932         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5933         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5934         ndr_print_uint32(ndr, "version", r->version);
5935         ndr_print_uint32(ndr, "free_build", r->free_build);
5936         ndr_print_uint32(ndr, "spooling", r->spooling);
5937         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5938         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5939         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5940         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5941         ndr_print_uint32(ndr, "job_error", r->job_error);
5942         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5943         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5944         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5945         ndr_print_uint32(ndr, "change_id", r->change_id);
5946         ndr_print_WERROR(ndr, "last_error", r->last_error);
5947         ndr_print_uint32(ndr, "status", r->status);
5948         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5949         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5950         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5951         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5952         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5953         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5954         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5955         ndr->depth--;
5956 }
5957
5958 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5959 {
5960         if (ndr_flags & NDR_SCALARS) {
5961                 NDR_CHECK(ndr_push_align(ndr, 4));
5962                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5966         }
5967         if (ndr_flags & NDR_BUFFERS) {
5968                 if (r->name) {
5969                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5970                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5973                 }
5974                 if (r->description) {
5975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5979                 }
5980                 if (r->comment) {
5981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5984                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5985                 }
5986         }
5987         return NDR_ERR_SUCCESS;
5988 }
5989
5990 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5991 {
5992         uint32_t _ptr_name;
5993         TALLOC_CTX *_mem_save_name_0;
5994         uint32_t _ptr_description;
5995         TALLOC_CTX *_mem_save_description_0;
5996         uint32_t _ptr_comment;
5997         TALLOC_CTX *_mem_save_comment_0;
5998         if (ndr_flags & NDR_SCALARS) {
5999                 NDR_CHECK(ndr_pull_align(ndr, 4));
6000                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
6001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6002                 if (_ptr_name) {
6003                         NDR_PULL_ALLOC(ndr, r->name);
6004                 } else {
6005                         r->name = NULL;
6006                 }
6007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6008                 if (_ptr_description) {
6009                         NDR_PULL_ALLOC(ndr, r->description);
6010                 } else {
6011                         r->description = NULL;
6012                 }
6013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6014                 if (_ptr_comment) {
6015                         NDR_PULL_ALLOC(ndr, r->comment);
6016                 } else {
6017                         r->comment = NULL;
6018                 }
6019         }
6020         if (ndr_flags & NDR_BUFFERS) {
6021                 if (r->name) {
6022                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6023                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6026                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6027                                 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));
6028                         }
6029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6032                 }
6033                 if (r->description) {
6034                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6035                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6038                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6039                                 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));
6040                         }
6041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6044                 }
6045                 if (r->comment) {
6046                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6047                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6050                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6051                                 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));
6052                         }
6053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6056                 }
6057         }
6058         return NDR_ERR_SUCCESS;
6059 }
6060
6061 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6062 {
6063         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6064         ndr->depth++;
6065         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
6066         ndr_print_ptr(ndr, "name", r->name);
6067         ndr->depth++;
6068         if (r->name) {
6069                 ndr_print_string(ndr, "name", r->name);
6070         }
6071         ndr->depth--;
6072         ndr_print_ptr(ndr, "description", r->description);
6073         ndr->depth++;
6074         if (r->description) {
6075                 ndr_print_string(ndr, "description", r->description);
6076         }
6077         ndr->depth--;
6078         ndr_print_ptr(ndr, "comment", r->comment);
6079         ndr->depth++;
6080         if (r->comment) {
6081                 ndr_print_string(ndr, "comment", r->comment);
6082         }
6083         ndr->depth--;
6084         ndr->depth--;
6085 }
6086
6087 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6088 {
6089         if (ndr_flags & NDR_SCALARS) {
6090                 NDR_CHECK(ndr_push_align(ndr, 4));
6091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6095                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6096                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6103                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6104                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6109                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6112         }
6113         if (ndr_flags & NDR_BUFFERS) {
6114                 if (r->servername) {
6115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6118                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6119                 }
6120                 if (r->printername) {
6121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6125                 }
6126                 if (r->sharename) {
6127                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6128                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6130                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6131                 }
6132                 if (r->portname) {
6133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6136                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6137                 }
6138                 if (r->drivername) {
6139                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6140                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6142                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6143                 }
6144                 if (r->comment) {
6145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6148                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6149                 }
6150                 if (r->location) {
6151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6154                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6155                 }
6156                 if (r->devmode) {
6157                         {
6158                                 struct ndr_push *_ndr_devmode;
6159                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6160                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6161                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6162                         }
6163                 }
6164                 if (r->sepfile) {
6165                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6168                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6169                 }
6170                 if (r->printprocessor) {
6171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6174                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6175                 }
6176                 if (r->datatype) {
6177                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6180                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6181                 }
6182                 if (r->parameters) {
6183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6186                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6187                 }
6188                 if (r->secdesc) {
6189                         {
6190                                 struct ndr_push *_ndr_secdesc;
6191                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6192                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6193                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6194                         }
6195                 }
6196         }
6197         return NDR_ERR_SUCCESS;
6198 }
6199
6200 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6201 {
6202         uint32_t _ptr_servername;
6203         TALLOC_CTX *_mem_save_servername_0;
6204         uint32_t _ptr_printername;
6205         TALLOC_CTX *_mem_save_printername_0;
6206         uint32_t _ptr_sharename;
6207         TALLOC_CTX *_mem_save_sharename_0;
6208         uint32_t _ptr_portname;
6209         TALLOC_CTX *_mem_save_portname_0;
6210         uint32_t _ptr_drivername;
6211         TALLOC_CTX *_mem_save_drivername_0;
6212         uint32_t _ptr_comment;
6213         TALLOC_CTX *_mem_save_comment_0;
6214         uint32_t _ptr_location;
6215         TALLOC_CTX *_mem_save_location_0;
6216         uint32_t _ptr_devmode;
6217         TALLOC_CTX *_mem_save_devmode_0;
6218         uint32_t _ptr_sepfile;
6219         TALLOC_CTX *_mem_save_sepfile_0;
6220         uint32_t _ptr_printprocessor;
6221         TALLOC_CTX *_mem_save_printprocessor_0;
6222         uint32_t _ptr_datatype;
6223         TALLOC_CTX *_mem_save_datatype_0;
6224         uint32_t _ptr_parameters;
6225         TALLOC_CTX *_mem_save_parameters_0;
6226         uint32_t _ptr_secdesc;
6227         TALLOC_CTX *_mem_save_secdesc_0;
6228         if (ndr_flags & NDR_SCALARS) {
6229                 NDR_CHECK(ndr_pull_align(ndr, 4));
6230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6231                 if (_ptr_servername) {
6232                         NDR_PULL_ALLOC(ndr, r->servername);
6233                 } else {
6234                         r->servername = NULL;
6235                 }
6236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6237                 if (_ptr_printername) {
6238                         NDR_PULL_ALLOC(ndr, r->printername);
6239                 } else {
6240                         r->printername = NULL;
6241                 }
6242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6243                 if (_ptr_sharename) {
6244                         NDR_PULL_ALLOC(ndr, r->sharename);
6245                 } else {
6246                         r->sharename = NULL;
6247                 }
6248                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6249                 if (_ptr_portname) {
6250                         NDR_PULL_ALLOC(ndr, r->portname);
6251                 } else {
6252                         r->portname = NULL;
6253                 }
6254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6255                 if (_ptr_drivername) {
6256                         NDR_PULL_ALLOC(ndr, r->drivername);
6257                 } else {
6258                         r->drivername = NULL;
6259                 }
6260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6261                 if (_ptr_comment) {
6262                         NDR_PULL_ALLOC(ndr, r->comment);
6263                 } else {
6264                         r->comment = NULL;
6265                 }
6266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6267                 if (_ptr_location) {
6268                         NDR_PULL_ALLOC(ndr, r->location);
6269                 } else {
6270                         r->location = NULL;
6271                 }
6272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6273                 if (_ptr_devmode) {
6274                         NDR_PULL_ALLOC(ndr, r->devmode);
6275                 } else {
6276                         r->devmode = NULL;
6277                 }
6278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6279                 if (_ptr_sepfile) {
6280                         NDR_PULL_ALLOC(ndr, r->sepfile);
6281                 } else {
6282                         r->sepfile = NULL;
6283                 }
6284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6285                 if (_ptr_printprocessor) {
6286                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6287                 } else {
6288                         r->printprocessor = NULL;
6289                 }
6290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6291                 if (_ptr_datatype) {
6292                         NDR_PULL_ALLOC(ndr, r->datatype);
6293                 } else {
6294                         r->datatype = NULL;
6295                 }
6296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6297                 if (_ptr_parameters) {
6298                         NDR_PULL_ALLOC(ndr, r->parameters);
6299                 } else {
6300                         r->parameters = NULL;
6301                 }
6302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6303                 if (_ptr_secdesc) {
6304                         NDR_PULL_ALLOC(ndr, r->secdesc);
6305                 } else {
6306                         r->secdesc = NULL;
6307                 }
6308                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6310                 if (r->priority > 99) {
6311                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6312                 }
6313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6316                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6319         }
6320         if (ndr_flags & NDR_BUFFERS) {
6321                 if (r->servername) {
6322                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6323                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6324                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6325                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6326                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6327                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6328                         }
6329                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6330                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6332                 }
6333                 if (r->printername) {
6334                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6335                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6338                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6339                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6340                         }
6341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6344                 }
6345                 if (r->sharename) {
6346                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6347                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6350                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6351                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
6352                         }
6353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6356                 }
6357                 if (r->portname) {
6358                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6359                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6362                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6363                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6364                         }
6365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6368                 }
6369                 if (r->drivername) {
6370                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6371                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6374                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6375                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
6376                         }
6377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6380                 }
6381                 if (r->comment) {
6382                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6383                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6386                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6387                                 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));
6388                         }
6389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6392                 }
6393                 if (r->location) {
6394                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6395                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6398                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6399                                 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));
6400                         }
6401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6402                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6404                 }
6405                 if (r->devmode) {
6406                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6407                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6408                         {
6409                                 struct ndr_pull *_ndr_devmode;
6410                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6411                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6412                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6413                         }
6414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6415                 }
6416                 if (r->sepfile) {
6417                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6418                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6419                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6420                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6421                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6422                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
6423                         }
6424                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6425                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6427                 }
6428                 if (r->printprocessor) {
6429                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6430                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6432                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6433                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6434                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
6435                         }
6436                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6439                 }
6440                 if (r->datatype) {
6441                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6442                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6443                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6444                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6445                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6446                                 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));
6447                         }
6448                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6449                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6451                 }
6452                 if (r->parameters) {
6453                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6454                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6455                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6456                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6457                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6458                                 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));
6459                         }
6460                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6461                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6463                 }
6464                 if (r->secdesc) {
6465                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6466                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6467                         {
6468                                 struct ndr_pull *_ndr_secdesc;
6469                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6470                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6471                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6472                         }
6473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6474                 }
6475         }
6476         return NDR_ERR_SUCCESS;
6477 }
6478
6479 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6480 {
6481         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6482         ndr->depth++;
6483         ndr_print_ptr(ndr, "servername", r->servername);
6484         ndr->depth++;
6485         if (r->servername) {
6486                 ndr_print_string(ndr, "servername", r->servername);
6487         }
6488         ndr->depth--;
6489         ndr_print_ptr(ndr, "printername", r->printername);
6490         ndr->depth++;
6491         if (r->printername) {
6492                 ndr_print_string(ndr, "printername", r->printername);
6493         }
6494         ndr->depth--;
6495         ndr_print_ptr(ndr, "sharename", r->sharename);
6496         ndr->depth++;
6497         if (r->sharename) {
6498                 ndr_print_string(ndr, "sharename", r->sharename);
6499         }
6500         ndr->depth--;
6501         ndr_print_ptr(ndr, "portname", r->portname);
6502         ndr->depth++;
6503         if (r->portname) {
6504                 ndr_print_string(ndr, "portname", r->portname);
6505         }
6506         ndr->depth--;
6507         ndr_print_ptr(ndr, "drivername", r->drivername);
6508         ndr->depth++;
6509         if (r->drivername) {
6510                 ndr_print_string(ndr, "drivername", r->drivername);
6511         }
6512         ndr->depth--;
6513         ndr_print_ptr(ndr, "comment", r->comment);
6514         ndr->depth++;
6515         if (r->comment) {
6516                 ndr_print_string(ndr, "comment", r->comment);
6517         }
6518         ndr->depth--;
6519         ndr_print_ptr(ndr, "location", r->location);
6520         ndr->depth++;
6521         if (r->location) {
6522                 ndr_print_string(ndr, "location", r->location);
6523         }
6524         ndr->depth--;
6525         ndr_print_ptr(ndr, "devmode", r->devmode);
6526         ndr->depth++;
6527         if (r->devmode) {
6528                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6529         }
6530         ndr->depth--;
6531         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6532         ndr->depth++;
6533         if (r->sepfile) {
6534                 ndr_print_string(ndr, "sepfile", r->sepfile);
6535         }
6536         ndr->depth--;
6537         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6538         ndr->depth++;
6539         if (r->printprocessor) {
6540                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6541         }
6542         ndr->depth--;
6543         ndr_print_ptr(ndr, "datatype", r->datatype);
6544         ndr->depth++;
6545         if (r->datatype) {
6546                 ndr_print_string(ndr, "datatype", r->datatype);
6547         }
6548         ndr->depth--;
6549         ndr_print_ptr(ndr, "parameters", r->parameters);
6550         ndr->depth++;
6551         if (r->parameters) {
6552                 ndr_print_string(ndr, "parameters", r->parameters);
6553         }
6554         ndr->depth--;
6555         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6556         ndr->depth++;
6557         if (r->secdesc) {
6558                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6559         }
6560         ndr->depth--;
6561         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6562         ndr_print_uint32(ndr, "priority", r->priority);
6563         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6564         ndr_print_uint32(ndr, "starttime", r->starttime);
6565         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6566         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6567         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6568         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6569         ndr->depth--;
6570 }
6571
6572 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6573 {
6574         if (ndr_flags & NDR_SCALARS) {
6575                 NDR_CHECK(ndr_push_align(ndr, 4));
6576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6577         }
6578         if (ndr_flags & NDR_BUFFERS) {
6579         }
6580         return NDR_ERR_SUCCESS;
6581 }
6582
6583 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6584 {
6585         if (ndr_flags & NDR_SCALARS) {
6586                 NDR_CHECK(ndr_pull_align(ndr, 4));
6587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6588         }
6589         if (ndr_flags & NDR_BUFFERS) {
6590         }
6591         return NDR_ERR_SUCCESS;
6592 }
6593
6594 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6595 {
6596         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6597         ndr->depth++;
6598         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6599         ndr->depth--;
6600 }
6601
6602 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6603 {
6604         if (ndr_flags & NDR_SCALARS) {
6605                 NDR_CHECK(ndr_push_align(ndr, 4));
6606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6608                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6609         }
6610         if (ndr_flags & NDR_BUFFERS) {
6611                 if (r->printername) {
6612                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6615                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6616                 }
6617                 if (r->servername) {
6618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6619                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6620                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6621                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6622                 }
6623         }
6624         return NDR_ERR_SUCCESS;
6625 }
6626
6627 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6628 {
6629         uint32_t _ptr_printername;
6630         TALLOC_CTX *_mem_save_printername_0;
6631         uint32_t _ptr_servername;
6632         TALLOC_CTX *_mem_save_servername_0;
6633         if (ndr_flags & NDR_SCALARS) {
6634                 NDR_CHECK(ndr_pull_align(ndr, 4));
6635                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6636                 if (_ptr_printername) {
6637                         NDR_PULL_ALLOC(ndr, r->printername);
6638                 } else {
6639                         r->printername = NULL;
6640                 }
6641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6642                 if (_ptr_servername) {
6643                         NDR_PULL_ALLOC(ndr, r->servername);
6644                 } else {
6645                         r->servername = NULL;
6646                 }
6647                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6648         }
6649         if (ndr_flags & NDR_BUFFERS) {
6650                 if (r->printername) {
6651                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6652                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6653                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6654                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6655                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6656                                 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));
6657                         }
6658                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6659                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6661                 }
6662                 if (r->servername) {
6663                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6664                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6666                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6667                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6668                                 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));
6669                         }
6670                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6671                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6673                 }
6674         }
6675         return NDR_ERR_SUCCESS;
6676 }
6677
6678 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6679 {
6680         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6681         ndr->depth++;
6682         ndr_print_ptr(ndr, "printername", r->printername);
6683         ndr->depth++;
6684         if (r->printername) {
6685                 ndr_print_string(ndr, "printername", r->printername);
6686         }
6687         ndr->depth--;
6688         ndr_print_ptr(ndr, "servername", r->servername);
6689         ndr->depth++;
6690         if (r->servername) {
6691                 ndr_print_string(ndr, "servername", r->servername);
6692         }
6693         ndr->depth--;
6694         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6695         ndr->depth--;
6696 }
6697
6698 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6699 {
6700         if (ndr_flags & NDR_SCALARS) {
6701                 NDR_CHECK(ndr_push_align(ndr, 4));
6702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6704                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6707         }
6708         if (ndr_flags & NDR_BUFFERS) {
6709                 if (r->printername) {
6710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6714                 }
6715                 if (r->portname) {
6716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6720                 }
6721         }
6722         return NDR_ERR_SUCCESS;
6723 }
6724
6725 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6726 {
6727         uint32_t _ptr_printername;
6728         TALLOC_CTX *_mem_save_printername_0;
6729         uint32_t _ptr_portname;
6730         TALLOC_CTX *_mem_save_portname_0;
6731         if (ndr_flags & NDR_SCALARS) {
6732                 NDR_CHECK(ndr_pull_align(ndr, 4));
6733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6734                 if (_ptr_printername) {
6735                         NDR_PULL_ALLOC(ndr, r->printername);
6736                 } else {
6737                         r->printername = NULL;
6738                 }
6739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6740                 if (_ptr_portname) {
6741                         NDR_PULL_ALLOC(ndr, r->portname);
6742                 } else {
6743                         r->portname = NULL;
6744                 }
6745                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6748         }
6749         if (ndr_flags & NDR_BUFFERS) {
6750                 if (r->printername) {
6751                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6752                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6755                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6756                                 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));
6757                         }
6758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6761                 }
6762                 if (r->portname) {
6763                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6764                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6767                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6768                                 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));
6769                         }
6770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6773                 }
6774         }
6775         return NDR_ERR_SUCCESS;
6776 }
6777
6778 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6779 {
6780         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6781         ndr->depth++;
6782         ndr_print_ptr(ndr, "printername", r->printername);
6783         ndr->depth++;
6784         if (r->printername) {
6785                 ndr_print_string(ndr, "printername", r->printername);
6786         }
6787         ndr->depth--;
6788         ndr_print_ptr(ndr, "portname", r->portname);
6789         ndr->depth++;
6790         if (r->portname) {
6791                 ndr_print_string(ndr, "portname", r->portname);
6792         }
6793         ndr->depth--;
6794         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6795         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6796         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6797         ndr->depth--;
6798 }
6799
6800 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6801 {
6802         if (ndr_flags & NDR_SCALARS) {
6803                 NDR_CHECK(ndr_push_align(ndr, 4));
6804                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6805         }
6806         if (ndr_flags & NDR_BUFFERS) {
6807         }
6808         return NDR_ERR_SUCCESS;
6809 }
6810
6811 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6812 {
6813         if (ndr_flags & NDR_SCALARS) {
6814                 NDR_CHECK(ndr_pull_align(ndr, 4));
6815                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6816         }
6817         if (ndr_flags & NDR_BUFFERS) {
6818         }
6819         return NDR_ERR_SUCCESS;
6820 }
6821
6822 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6823 {
6824         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6825         ndr->depth++;
6826         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6827         ndr->depth--;
6828 }
6829
6830 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6831 {
6832         if (ndr_flags & NDR_SCALARS) {
6833                 NDR_CHECK(ndr_push_align(ndr, 4));
6834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6835                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6836         }
6837         if (ndr_flags & NDR_BUFFERS) {
6838                 if (r->guid) {
6839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6843                 }
6844         }
6845         return NDR_ERR_SUCCESS;
6846 }
6847
6848 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6849 {
6850         uint32_t _ptr_guid;
6851         TALLOC_CTX *_mem_save_guid_0;
6852         if (ndr_flags & NDR_SCALARS) {
6853                 NDR_CHECK(ndr_pull_align(ndr, 4));
6854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6855                 if (_ptr_guid) {
6856                         NDR_PULL_ALLOC(ndr, r->guid);
6857                 } else {
6858                         r->guid = NULL;
6859                 }
6860                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6861         }
6862         if (ndr_flags & NDR_BUFFERS) {
6863                 if (r->guid) {
6864                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6865                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6868                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6869                                 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));
6870                         }
6871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6874                 }
6875         }
6876         return NDR_ERR_SUCCESS;
6877 }
6878
6879 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6880 {
6881         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6882         ndr->depth++;
6883         ndr_print_ptr(ndr, "guid", r->guid);
6884         ndr->depth++;
6885         if (r->guid) {
6886                 ndr_print_string(ndr, "guid", r->guid);
6887         }
6888         ndr->depth--;
6889         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6890         ndr->depth--;
6891 }
6892
6893 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6894 {
6895         if (ndr_flags & NDR_SCALARS) {
6896                 int level = ndr_push_get_switch_value(ndr, r);
6897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6898                 switch (level) {
6899                         case 0: {
6900                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6901                         break; }
6902
6903                         case 1: {
6904                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6905                         break; }
6906
6907                         case 2: {
6908                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6909                         break; }
6910
6911                         case 3: {
6912                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6913                         break; }
6914
6915                         case 4: {
6916                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6917                         break; }
6918
6919                         case 5: {
6920                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6921                         break; }
6922
6923                         case 6: {
6924                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6925                         break; }
6926
6927                         case 7: {
6928                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6929                         break; }
6930
6931                         case 8: {
6932                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6933                         break; }
6934
6935                         case 9: {
6936                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6937                         break; }
6938
6939                         default: {
6940                         break; }
6941
6942                 }
6943         }
6944         if (ndr_flags & NDR_BUFFERS) {
6945                 int level = ndr_push_get_switch_value(ndr, r);
6946                 switch (level) {
6947                         case 0:
6948                                 if (r->info0) {
6949                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6950                                 }
6951                         break;
6952
6953                         case 1:
6954                                 if (r->info1) {
6955                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6956                                 }
6957                         break;
6958
6959                         case 2:
6960                                 if (r->info2) {
6961                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6962                                 }
6963                         break;
6964
6965                         case 3:
6966                                 if (r->info3) {
6967                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6968                                 }
6969                         break;
6970
6971                         case 4:
6972                                 if (r->info4) {
6973                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6974                                 }
6975                         break;
6976
6977                         case 5:
6978                                 if (r->info5) {
6979                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6980                                 }
6981                         break;
6982
6983                         case 6:
6984                                 if (r->info6) {
6985                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6986                                 }
6987                         break;
6988
6989                         case 7:
6990                                 if (r->info7) {
6991                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6992                                 }
6993                         break;
6994
6995                         case 8:
6996                                 if (r->info8) {
6997                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6998                                 }
6999                         break;
7000
7001                         case 9:
7002                                 if (r->info9) {
7003                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7004                                 }
7005                         break;
7006
7007                         default:
7008                         break;
7009
7010                 }
7011         }
7012         return NDR_ERR_SUCCESS;
7013 }
7014
7015 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7016 {
7017         int level;
7018         uint32_t _level;
7019         TALLOC_CTX *_mem_save_info0_0;
7020         TALLOC_CTX *_mem_save_info1_0;
7021         TALLOC_CTX *_mem_save_info2_0;
7022         TALLOC_CTX *_mem_save_info3_0;
7023         TALLOC_CTX *_mem_save_info4_0;
7024         TALLOC_CTX *_mem_save_info5_0;
7025         TALLOC_CTX *_mem_save_info6_0;
7026         TALLOC_CTX *_mem_save_info7_0;
7027         TALLOC_CTX *_mem_save_info8_0;
7028         TALLOC_CTX *_mem_save_info9_0;
7029         level = ndr_pull_get_switch_value(ndr, r);
7030         if (ndr_flags & NDR_SCALARS) {
7031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7032                 if (_level != level) {
7033                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7034                 }
7035                 switch (level) {
7036                         case 0: {
7037                                 uint32_t _ptr_info0;
7038                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7039                                 if (_ptr_info0) {
7040                                         NDR_PULL_ALLOC(ndr, r->info0);
7041                                 } else {
7042                                         r->info0 = NULL;
7043                                 }
7044                         break; }
7045
7046                         case 1: {
7047                                 uint32_t _ptr_info1;
7048                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7049                                 if (_ptr_info1) {
7050                                         NDR_PULL_ALLOC(ndr, r->info1);
7051                                 } else {
7052                                         r->info1 = NULL;
7053                                 }
7054                         break; }
7055
7056                         case 2: {
7057                                 uint32_t _ptr_info2;
7058                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7059                                 if (_ptr_info2) {
7060                                         NDR_PULL_ALLOC(ndr, r->info2);
7061                                 } else {
7062                                         r->info2 = NULL;
7063                                 }
7064                         break; }
7065
7066                         case 3: {
7067                                 uint32_t _ptr_info3;
7068                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7069                                 if (_ptr_info3) {
7070                                         NDR_PULL_ALLOC(ndr, r->info3);
7071                                 } else {
7072                                         r->info3 = NULL;
7073                                 }
7074                         break; }
7075
7076                         case 4: {
7077                                 uint32_t _ptr_info4;
7078                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7079                                 if (_ptr_info4) {
7080                                         NDR_PULL_ALLOC(ndr, r->info4);
7081                                 } else {
7082                                         r->info4 = NULL;
7083                                 }
7084                         break; }
7085
7086                         case 5: {
7087                                 uint32_t _ptr_info5;
7088                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7089                                 if (_ptr_info5) {
7090                                         NDR_PULL_ALLOC(ndr, r->info5);
7091                                 } else {
7092                                         r->info5 = NULL;
7093                                 }
7094                         break; }
7095
7096                         case 6: {
7097                                 uint32_t _ptr_info6;
7098                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7099                                 if (_ptr_info6) {
7100                                         NDR_PULL_ALLOC(ndr, r->info6);
7101                                 } else {
7102                                         r->info6 = NULL;
7103                                 }
7104                         break; }
7105
7106                         case 7: {
7107                                 uint32_t _ptr_info7;
7108                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7109                                 if (_ptr_info7) {
7110                                         NDR_PULL_ALLOC(ndr, r->info7);
7111                                 } else {
7112                                         r->info7 = NULL;
7113                                 }
7114                         break; }
7115
7116                         case 8: {
7117                                 uint32_t _ptr_info8;
7118                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7119                                 if (_ptr_info8) {
7120                                         NDR_PULL_ALLOC(ndr, r->info8);
7121                                 } else {
7122                                         r->info8 = NULL;
7123                                 }
7124                         break; }
7125
7126                         case 9: {
7127                                 uint32_t _ptr_info9;
7128                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7129                                 if (_ptr_info9) {
7130                                         NDR_PULL_ALLOC(ndr, r->info9);
7131                                 } else {
7132                                         r->info9 = NULL;
7133                                 }
7134                         break; }
7135
7136                         default: {
7137                         break; }
7138
7139                 }
7140         }
7141         if (ndr_flags & NDR_BUFFERS) {
7142                 switch (level) {
7143                         case 0:
7144                                 if (r->info0) {
7145                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7146                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7147                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7148                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7149                                 }
7150                         break;
7151
7152                         case 1:
7153                                 if (r->info1) {
7154                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7155                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7156                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7157                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7158                                 }
7159                         break;
7160
7161                         case 2:
7162                                 if (r->info2) {
7163                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7164                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7165                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7166                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7167                                 }
7168                         break;
7169
7170                         case 3:
7171                                 if (r->info3) {
7172                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7173                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7174                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7175                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7176                                 }
7177                         break;
7178
7179                         case 4:
7180                                 if (r->info4) {
7181                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7182                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7183                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7184                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7185                                 }
7186                         break;
7187
7188                         case 5:
7189                                 if (r->info5) {
7190                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7191                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7192                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7193                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7194                                 }
7195                         break;
7196
7197                         case 6:
7198                                 if (r->info6) {
7199                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7200                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7201                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7202                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7203                                 }
7204                         break;
7205
7206                         case 7:
7207                                 if (r->info7) {
7208                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7209                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7210                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7211                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7212                                 }
7213                         break;
7214
7215                         case 8:
7216                                 if (r->info8) {
7217                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7218                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7219                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7220                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7221                                 }
7222                         break;
7223
7224                         case 9:
7225                                 if (r->info9) {
7226                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7227                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7228                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7229                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7230                                 }
7231                         break;
7232
7233                         default:
7234                         break;
7235
7236                 }
7237         }
7238         return NDR_ERR_SUCCESS;
7239 }
7240
7241 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7242 {
7243         int level;
7244         level = ndr_print_get_switch_value(ndr, r);
7245         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7246         switch (level) {
7247                 case 0:
7248                         ndr_print_ptr(ndr, "info0", r->info0);
7249                         ndr->depth++;
7250                         if (r->info0) {
7251                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7252                         }
7253                         ndr->depth--;
7254                 break;
7255
7256                 case 1:
7257                         ndr_print_ptr(ndr, "info1", r->info1);
7258                         ndr->depth++;
7259                         if (r->info1) {
7260                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7261                         }
7262                         ndr->depth--;
7263                 break;
7264
7265                 case 2:
7266                         ndr_print_ptr(ndr, "info2", r->info2);
7267                         ndr->depth++;
7268                         if (r->info2) {
7269                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7270                         }
7271                         ndr->depth--;
7272                 break;
7273
7274                 case 3:
7275                         ndr_print_ptr(ndr, "info3", r->info3);
7276                         ndr->depth++;
7277                         if (r->info3) {
7278                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7279                         }
7280                         ndr->depth--;
7281                 break;
7282
7283                 case 4:
7284                         ndr_print_ptr(ndr, "info4", r->info4);
7285                         ndr->depth++;
7286                         if (r->info4) {
7287                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7288                         }
7289                         ndr->depth--;
7290                 break;
7291
7292                 case 5:
7293                         ndr_print_ptr(ndr, "info5", r->info5);
7294                         ndr->depth++;
7295                         if (r->info5) {
7296                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7297                         }
7298                         ndr->depth--;
7299                 break;
7300
7301                 case 6:
7302                         ndr_print_ptr(ndr, "info6", r->info6);
7303                         ndr->depth++;
7304                         if (r->info6) {
7305                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7306                         }
7307                         ndr->depth--;
7308                 break;
7309
7310                 case 7:
7311                         ndr_print_ptr(ndr, "info7", r->info7);
7312                         ndr->depth++;
7313                         if (r->info7) {
7314                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7315                         }
7316                         ndr->depth--;
7317                 break;
7318
7319                 case 8:
7320                         ndr_print_ptr(ndr, "info8", r->info8);
7321                         ndr->depth++;
7322                         if (r->info8) {
7323                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7324                         }
7325                         ndr->depth--;
7326                 break;
7327
7328                 case 9:
7329                         ndr_print_ptr(ndr, "info9", r->info9);
7330                         ndr->depth++;
7331                         if (r->info9) {
7332                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7333                         }
7334                         ndr->depth--;
7335                 break;
7336
7337                 default:
7338                 break;
7339
7340         }
7341 }
7342
7343 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7344 {
7345         if (ndr_flags & NDR_SCALARS) {
7346                 NDR_CHECK(ndr_push_align(ndr, 4));
7347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7348                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7349                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7350         }
7351         if (ndr_flags & NDR_BUFFERS) {
7352                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7353         }
7354         return NDR_ERR_SUCCESS;
7355 }
7356
7357 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7358 {
7359         if (ndr_flags & NDR_SCALARS) {
7360                 NDR_CHECK(ndr_pull_align(ndr, 4));
7361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7362                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7363                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7364         }
7365         if (ndr_flags & NDR_BUFFERS) {
7366                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7367         }
7368         return NDR_ERR_SUCCESS;
7369 }
7370
7371 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7372 {
7373         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7374         ndr->depth++;
7375         ndr_print_uint32(ndr, "level", r->level);
7376         ndr_print_set_switch_value(ndr, &r->info, r->level);
7377         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7378         ndr->depth--;
7379 }
7380
7381 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7382 {
7383         if (ndr_flags & NDR_SCALARS) {
7384                 NDR_CHECK(ndr_push_align(ndr, 4));
7385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7386                 {
7387                         uint32_t _flags_save_string_array = ndr->flags;
7388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7389                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7390                         ndr->flags = _flags_save_string_array;
7391                 }
7392         }
7393         if (ndr_flags & NDR_BUFFERS) {
7394         }
7395         return NDR_ERR_SUCCESS;
7396 }
7397
7398 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7399 {
7400         if (ndr_flags & NDR_SCALARS) {
7401                 NDR_CHECK(ndr_pull_align(ndr, 4));
7402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7403                 {
7404                         uint32_t _flags_save_string_array = ndr->flags;
7405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7406                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7407                         ndr->flags = _flags_save_string_array;
7408                 }
7409         }
7410         if (ndr_flags & NDR_BUFFERS) {
7411         }
7412         return NDR_ERR_SUCCESS;
7413 }
7414
7415 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7416 {
7417         ndr_print_struct(ndr, name, "spoolss_StringArray");
7418         ndr->depth++;
7419         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);
7420         ndr_print_string_array(ndr, "string", r->string);
7421         ndr->depth--;
7422 }
7423
7424 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7425 {
7426         if (ndr_flags & NDR_SCALARS) {
7427                 NDR_CHECK(ndr_push_align(ndr, 4));
7428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7429         }
7430         if (ndr_flags & NDR_BUFFERS) {
7431                 if (r->driver_name) {
7432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7435                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7436                 }
7437         }
7438         return NDR_ERR_SUCCESS;
7439 }
7440
7441 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7442 {
7443         uint32_t _ptr_driver_name;
7444         TALLOC_CTX *_mem_save_driver_name_0;
7445         if (ndr_flags & NDR_SCALARS) {
7446                 NDR_CHECK(ndr_pull_align(ndr, 4));
7447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7448                 if (_ptr_driver_name) {
7449                         NDR_PULL_ALLOC(ndr, r->driver_name);
7450                 } else {
7451                         r->driver_name = NULL;
7452                 }
7453         }
7454         if (ndr_flags & NDR_BUFFERS) {
7455                 if (r->driver_name) {
7456                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7457                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7458                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7459                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7460                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7461                                 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));
7462                         }
7463                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7464                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7465                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7466                 }
7467         }
7468         return NDR_ERR_SUCCESS;
7469 }
7470
7471 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7472 {
7473         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7474         ndr->depth++;
7475         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7476         ndr->depth++;
7477         if (r->driver_name) {
7478                 ndr_print_string(ndr, "driver_name", r->driver_name);
7479         }
7480         ndr->depth--;
7481         ndr->depth--;
7482 }
7483
7484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7485 {
7486         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7487         return NDR_ERR_SUCCESS;
7488 }
7489
7490 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7491 {
7492         uint32_t v;
7493         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7494         *r = v;
7495         return NDR_ERR_SUCCESS;
7496 }
7497
7498 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7499 {
7500         const char *val = NULL;
7501
7502         switch (r) {
7503                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7504                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7505                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7506                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7507         }
7508         ndr_print_enum(ndr, name, "ENUM", val, r);
7509 }
7510
7511 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7512 {
7513         if (ndr_flags & NDR_SCALARS) {
7514                 NDR_CHECK(ndr_push_align(ndr, 4));
7515                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7521         }
7522         if (ndr_flags & NDR_BUFFERS) {
7523                 if (r->driver_name) {
7524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7528                 }
7529                 if (r->architecture) {
7530                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7533                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7534                 }
7535                 if (r->driver_path) {
7536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7540                 }
7541                 if (r->data_file) {
7542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7546                 }
7547                 if (r->config_file) {
7548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7551                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7552                 }
7553         }
7554         return NDR_ERR_SUCCESS;
7555 }
7556
7557 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7558 {
7559         uint32_t _ptr_driver_name;
7560         TALLOC_CTX *_mem_save_driver_name_0;
7561         uint32_t _ptr_architecture;
7562         TALLOC_CTX *_mem_save_architecture_0;
7563         uint32_t _ptr_driver_path;
7564         TALLOC_CTX *_mem_save_driver_path_0;
7565         uint32_t _ptr_data_file;
7566         TALLOC_CTX *_mem_save_data_file_0;
7567         uint32_t _ptr_config_file;
7568         TALLOC_CTX *_mem_save_config_file_0;
7569         if (ndr_flags & NDR_SCALARS) {
7570                 NDR_CHECK(ndr_pull_align(ndr, 4));
7571                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7573                 if (_ptr_driver_name) {
7574                         NDR_PULL_ALLOC(ndr, r->driver_name);
7575                 } else {
7576                         r->driver_name = NULL;
7577                 }
7578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7579                 if (_ptr_architecture) {
7580                         NDR_PULL_ALLOC(ndr, r->architecture);
7581                 } else {
7582                         r->architecture = NULL;
7583                 }
7584                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7585                 if (_ptr_driver_path) {
7586                         NDR_PULL_ALLOC(ndr, r->driver_path);
7587                 } else {
7588                         r->driver_path = NULL;
7589                 }
7590                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7591                 if (_ptr_data_file) {
7592                         NDR_PULL_ALLOC(ndr, r->data_file);
7593                 } else {
7594                         r->data_file = NULL;
7595                 }
7596                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7597                 if (_ptr_config_file) {
7598                         NDR_PULL_ALLOC(ndr, r->config_file);
7599                 } else {
7600                         r->config_file = NULL;
7601                 }
7602         }
7603         if (ndr_flags & NDR_BUFFERS) {
7604                 if (r->driver_name) {
7605                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7606                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7609                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7610                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7611                         }
7612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7615                 }
7616                 if (r->architecture) {
7617                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7618                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7621                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7622                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7623                         }
7624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7627                 }
7628                 if (r->driver_path) {
7629                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7630                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7631                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7632                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7633                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7634                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7635                         }
7636                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7637                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7639                 }
7640                 if (r->data_file) {
7641                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7642                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7644                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7645                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7646                                 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));
7647                         }
7648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7651                 }
7652                 if (r->config_file) {
7653                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7654                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7657                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7658                                 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));
7659                         }
7660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7661                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7663                 }
7664         }
7665         return NDR_ERR_SUCCESS;
7666 }
7667
7668 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7669 {
7670         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7671         ndr->depth++;
7672         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7673         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7674         ndr->depth++;
7675         if (r->driver_name) {
7676                 ndr_print_string(ndr, "driver_name", r->driver_name);
7677         }
7678         ndr->depth--;
7679         ndr_print_ptr(ndr, "architecture", r->architecture);
7680         ndr->depth++;
7681         if (r->architecture) {
7682                 ndr_print_string(ndr, "architecture", r->architecture);
7683         }
7684         ndr->depth--;
7685         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7686         ndr->depth++;
7687         if (r->driver_path) {
7688                 ndr_print_string(ndr, "driver_path", r->driver_path);
7689         }
7690         ndr->depth--;
7691         ndr_print_ptr(ndr, "data_file", r->data_file);
7692         ndr->depth++;
7693         if (r->data_file) {
7694                 ndr_print_string(ndr, "data_file", r->data_file);
7695         }
7696         ndr->depth--;
7697         ndr_print_ptr(ndr, "config_file", r->config_file);
7698         ndr->depth++;
7699         if (r->config_file) {
7700                 ndr_print_string(ndr, "config_file", r->config_file);
7701         }
7702         ndr->depth--;
7703         ndr->depth--;
7704 }
7705
7706 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7707 {
7708         if (ndr_flags & NDR_SCALARS) {
7709                 NDR_CHECK(ndr_push_align(ndr, 4));
7710                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7720                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7721         }
7722         if (ndr_flags & NDR_BUFFERS) {
7723                 if (r->driver_name) {
7724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7727                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7728                 }
7729                 if (r->architecture) {
7730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7734                 }
7735                 if (r->driver_path) {
7736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7740                 }
7741                 if (r->data_file) {
7742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7744                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7745                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7746                 }
7747                 if (r->config_file) {
7748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7750                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7751                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7752                 }
7753                 if (r->help_file) {
7754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7757                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7758                 }
7759                 if (r->monitor_name) {
7760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7761                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7764                 }
7765                 if (r->default_datatype) {
7766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7769                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7770                 }
7771                 if (r->dependent_files) {
7772                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7773                 }
7774         }
7775         return NDR_ERR_SUCCESS;
7776 }
7777
7778 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7779 {
7780         uint32_t _ptr_driver_name;
7781         TALLOC_CTX *_mem_save_driver_name_0;
7782         uint32_t _ptr_architecture;
7783         TALLOC_CTX *_mem_save_architecture_0;
7784         uint32_t _ptr_driver_path;
7785         TALLOC_CTX *_mem_save_driver_path_0;
7786         uint32_t _ptr_data_file;
7787         TALLOC_CTX *_mem_save_data_file_0;
7788         uint32_t _ptr_config_file;
7789         TALLOC_CTX *_mem_save_config_file_0;
7790         uint32_t _ptr_help_file;
7791         TALLOC_CTX *_mem_save_help_file_0;
7792         uint32_t _ptr_monitor_name;
7793         TALLOC_CTX *_mem_save_monitor_name_0;
7794         uint32_t _ptr_default_datatype;
7795         TALLOC_CTX *_mem_save_default_datatype_0;
7796         uint32_t _ptr_dependent_files;
7797         TALLOC_CTX *_mem_save_dependent_files_0;
7798         if (ndr_flags & NDR_SCALARS) {
7799                 NDR_CHECK(ndr_pull_align(ndr, 4));
7800                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7802                 if (_ptr_driver_name) {
7803                         NDR_PULL_ALLOC(ndr, r->driver_name);
7804                 } else {
7805                         r->driver_name = NULL;
7806                 }
7807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7808                 if (_ptr_architecture) {
7809                         NDR_PULL_ALLOC(ndr, r->architecture);
7810                 } else {
7811                         r->architecture = NULL;
7812                 }
7813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7814                 if (_ptr_driver_path) {
7815                         NDR_PULL_ALLOC(ndr, r->driver_path);
7816                 } else {
7817                         r->driver_path = NULL;
7818                 }
7819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7820                 if (_ptr_data_file) {
7821                         NDR_PULL_ALLOC(ndr, r->data_file);
7822                 } else {
7823                         r->data_file = NULL;
7824                 }
7825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7826                 if (_ptr_config_file) {
7827                         NDR_PULL_ALLOC(ndr, r->config_file);
7828                 } else {
7829                         r->config_file = NULL;
7830                 }
7831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7832                 if (_ptr_help_file) {
7833                         NDR_PULL_ALLOC(ndr, r->help_file);
7834                 } else {
7835                         r->help_file = NULL;
7836                 }
7837                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7838                 if (_ptr_monitor_name) {
7839                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7840                 } else {
7841                         r->monitor_name = NULL;
7842                 }
7843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7844                 if (_ptr_default_datatype) {
7845                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7846                 } else {
7847                         r->default_datatype = NULL;
7848                 }
7849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7851                 if (_ptr_dependent_files) {
7852                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7853                 } else {
7854                         r->dependent_files = NULL;
7855                 }
7856         }
7857         if (ndr_flags & NDR_BUFFERS) {
7858                 if (r->driver_name) {
7859                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7860                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7863                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7864                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7865                         }
7866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7869                 }
7870                 if (r->architecture) {
7871                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7872                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7875                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7876                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7877                         }
7878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7881                 }
7882                 if (r->driver_path) {
7883                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7884                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7887                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7888                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7889                         }
7890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7893                 }
7894                 if (r->data_file) {
7895                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7896                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7898                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7899                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7900                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7901                         }
7902                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7903                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7905                 }
7906                 if (r->config_file) {
7907                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7908                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7909                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7910                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7911                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7912                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7913                         }
7914                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7915                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7917                 }
7918                 if (r->help_file) {
7919                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7920                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7923                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7924                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
7925                         }
7926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7929                 }
7930                 if (r->monitor_name) {
7931                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7932                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7935                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7936                                 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));
7937                         }
7938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7941                 }
7942                 if (r->default_datatype) {
7943                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7944                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7947                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7948                                 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));
7949                         }
7950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7953                 }
7954                 if (r->dependent_files) {
7955                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7956                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7957                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7959                 }
7960         }
7961         return NDR_ERR_SUCCESS;
7962 }
7963
7964 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7965 {
7966         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7967         ndr->depth++;
7968         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7969         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7970         ndr->depth++;
7971         if (r->driver_name) {
7972                 ndr_print_string(ndr, "driver_name", r->driver_name);
7973         }
7974         ndr->depth--;
7975         ndr_print_ptr(ndr, "architecture", r->architecture);
7976         ndr->depth++;
7977         if (r->architecture) {
7978                 ndr_print_string(ndr, "architecture", r->architecture);
7979         }
7980         ndr->depth--;
7981         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7982         ndr->depth++;
7983         if (r->driver_path) {
7984                 ndr_print_string(ndr, "driver_path", r->driver_path);
7985         }
7986         ndr->depth--;
7987         ndr_print_ptr(ndr, "data_file", r->data_file);
7988         ndr->depth++;
7989         if (r->data_file) {
7990                 ndr_print_string(ndr, "data_file", r->data_file);
7991         }
7992         ndr->depth--;
7993         ndr_print_ptr(ndr, "config_file", r->config_file);
7994         ndr->depth++;
7995         if (r->config_file) {
7996                 ndr_print_string(ndr, "config_file", r->config_file);
7997         }
7998         ndr->depth--;
7999         ndr_print_ptr(ndr, "help_file", r->help_file);
8000         ndr->depth++;
8001         if (r->help_file) {
8002                 ndr_print_string(ndr, "help_file", r->help_file);
8003         }
8004         ndr->depth--;
8005         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8006         ndr->depth++;
8007         if (r->monitor_name) {
8008                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8009         }
8010         ndr->depth--;
8011         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8012         ndr->depth++;
8013         if (r->default_datatype) {
8014                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8015         }
8016         ndr->depth--;
8017         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);
8018         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8019         ndr->depth++;
8020         if (r->dependent_files) {
8021                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8022         }
8023         ndr->depth--;
8024         ndr->depth--;
8025 }
8026
8027 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8028 {
8029         if (ndr_flags & NDR_SCALARS) {
8030                 NDR_CHECK(ndr_push_align(ndr, 4));
8031                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8044         }
8045         if (ndr_flags & NDR_BUFFERS) {
8046                 if (r->driver_name) {
8047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8051                 }
8052                 if (r->architecture) {
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8057                 }
8058                 if (r->driver_path) {
8059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8063                 }
8064                 if (r->data_file) {
8065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8069                 }
8070                 if (r->config_file) {
8071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8075                 }
8076                 if (r->help_file) {
8077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8078                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8080                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8081                 }
8082                 if (r->monitor_name) {
8083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8086                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8087                 }
8088                 if (r->default_datatype) {
8089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8091                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8092                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8093                 }
8094                 if (r->dependent_files) {
8095                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8096                 }
8097                 if (r->previous_names) {
8098                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8099                 }
8100         }
8101         return NDR_ERR_SUCCESS;
8102 }
8103
8104 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8105 {
8106         uint32_t _ptr_driver_name;
8107         TALLOC_CTX *_mem_save_driver_name_0;
8108         uint32_t _ptr_architecture;
8109         TALLOC_CTX *_mem_save_architecture_0;
8110         uint32_t _ptr_driver_path;
8111         TALLOC_CTX *_mem_save_driver_path_0;
8112         uint32_t _ptr_data_file;
8113         TALLOC_CTX *_mem_save_data_file_0;
8114         uint32_t _ptr_config_file;
8115         TALLOC_CTX *_mem_save_config_file_0;
8116         uint32_t _ptr_help_file;
8117         TALLOC_CTX *_mem_save_help_file_0;
8118         uint32_t _ptr_monitor_name;
8119         TALLOC_CTX *_mem_save_monitor_name_0;
8120         uint32_t _ptr_default_datatype;
8121         TALLOC_CTX *_mem_save_default_datatype_0;
8122         uint32_t _ptr_dependent_files;
8123         TALLOC_CTX *_mem_save_dependent_files_0;
8124         uint32_t _ptr_previous_names;
8125         TALLOC_CTX *_mem_save_previous_names_0;
8126         if (ndr_flags & NDR_SCALARS) {
8127                 NDR_CHECK(ndr_pull_align(ndr, 4));
8128                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8130                 if (_ptr_driver_name) {
8131                         NDR_PULL_ALLOC(ndr, r->driver_name);
8132                 } else {
8133                         r->driver_name = NULL;
8134                 }
8135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8136                 if (_ptr_architecture) {
8137                         NDR_PULL_ALLOC(ndr, r->architecture);
8138                 } else {
8139                         r->architecture = NULL;
8140                 }
8141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8142                 if (_ptr_driver_path) {
8143                         NDR_PULL_ALLOC(ndr, r->driver_path);
8144                 } else {
8145                         r->driver_path = NULL;
8146                 }
8147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8148                 if (_ptr_data_file) {
8149                         NDR_PULL_ALLOC(ndr, r->data_file);
8150                 } else {
8151                         r->data_file = NULL;
8152                 }
8153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8154                 if (_ptr_config_file) {
8155                         NDR_PULL_ALLOC(ndr, r->config_file);
8156                 } else {
8157                         r->config_file = NULL;
8158                 }
8159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8160                 if (_ptr_help_file) {
8161                         NDR_PULL_ALLOC(ndr, r->help_file);
8162                 } else {
8163                         r->help_file = NULL;
8164                 }
8165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8166                 if (_ptr_monitor_name) {
8167                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8168                 } else {
8169                         r->monitor_name = NULL;
8170                 }
8171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8172                 if (_ptr_default_datatype) {
8173                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8174                 } else {
8175                         r->default_datatype = NULL;
8176                 }
8177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8179                 if (_ptr_dependent_files) {
8180                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8181                 } else {
8182                         r->dependent_files = NULL;
8183                 }
8184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8186                 if (_ptr_previous_names) {
8187                         NDR_PULL_ALLOC(ndr, r->previous_names);
8188                 } else {
8189                         r->previous_names = NULL;
8190                 }
8191         }
8192         if (ndr_flags & NDR_BUFFERS) {
8193                 if (r->driver_name) {
8194                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8195                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8198                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8200                         }
8201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8204                 }
8205                 if (r->architecture) {
8206                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8207                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8210                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8211                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8212                         }
8213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8216                 }
8217                 if (r->driver_path) {
8218                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8219                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8222                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8224                         }
8225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8228                 }
8229                 if (r->data_file) {
8230                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8231                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8234                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8236                         }
8237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8240                 }
8241                 if (r->config_file) {
8242                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8243                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8246                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8247                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8248                         }
8249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8252                 }
8253                 if (r->help_file) {
8254                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8255                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8258                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8259                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8260                         }
8261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8264                 }
8265                 if (r->monitor_name) {
8266                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8267                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8270                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8271                                 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));
8272                         }
8273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8276                 }
8277                 if (r->default_datatype) {
8278                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8279                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8282                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8283                                 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));
8284                         }
8285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8288                 }
8289                 if (r->dependent_files) {
8290                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8291                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8292                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8294                 }
8295                 if (r->previous_names) {
8296                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8297                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8298                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8300                 }
8301         }
8302         return NDR_ERR_SUCCESS;
8303 }
8304
8305 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8306 {
8307         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8308         ndr->depth++;
8309         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8310         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8311         ndr->depth++;
8312         if (r->driver_name) {
8313                 ndr_print_string(ndr, "driver_name", r->driver_name);
8314         }
8315         ndr->depth--;
8316         ndr_print_ptr(ndr, "architecture", r->architecture);
8317         ndr->depth++;
8318         if (r->architecture) {
8319                 ndr_print_string(ndr, "architecture", r->architecture);
8320         }
8321         ndr->depth--;
8322         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8323         ndr->depth++;
8324         if (r->driver_path) {
8325                 ndr_print_string(ndr, "driver_path", r->driver_path);
8326         }
8327         ndr->depth--;
8328         ndr_print_ptr(ndr, "data_file", r->data_file);
8329         ndr->depth++;
8330         if (r->data_file) {
8331                 ndr_print_string(ndr, "data_file", r->data_file);
8332         }
8333         ndr->depth--;
8334         ndr_print_ptr(ndr, "config_file", r->config_file);
8335         ndr->depth++;
8336         if (r->config_file) {
8337                 ndr_print_string(ndr, "config_file", r->config_file);
8338         }
8339         ndr->depth--;
8340         ndr_print_ptr(ndr, "help_file", r->help_file);
8341         ndr->depth++;
8342         if (r->help_file) {
8343                 ndr_print_string(ndr, "help_file", r->help_file);
8344         }
8345         ndr->depth--;
8346         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8347         ndr->depth++;
8348         if (r->monitor_name) {
8349                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8350         }
8351         ndr->depth--;
8352         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8353         ndr->depth++;
8354         if (r->default_datatype) {
8355                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8356         }
8357         ndr->depth--;
8358         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);
8359         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8360         ndr->depth++;
8361         if (r->dependent_files) {
8362                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8363         }
8364         ndr->depth--;
8365         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);
8366         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8367         ndr->depth++;
8368         if (r->previous_names) {
8369                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8370         }
8371         ndr->depth--;
8372         ndr->depth--;
8373 }
8374
8375 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8376 {
8377         if (ndr_flags & NDR_SCALARS) {
8378                 NDR_CHECK(ndr_push_align(ndr, 8));
8379                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8381                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8385                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8392                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8393                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8398         }
8399         if (ndr_flags & NDR_BUFFERS) {
8400                 if (r->driver_name) {
8401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8405                 }
8406                 if (r->architecture) {
8407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8411                 }
8412                 if (r->driver_path) {
8413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8416                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8417                 }
8418                 if (r->data_file) {
8419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8421                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8422                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8423                 }
8424                 if (r->config_file) {
8425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8428                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8429                 }
8430                 if (r->help_file) {
8431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8435                 }
8436                 if (r->monitor_name) {
8437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8441                 }
8442                 if (r->default_datatype) {
8443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8447                 }
8448                 if (r->dependent_files) {
8449                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8450                 }
8451                 if (r->previous_names) {
8452                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8453                 }
8454                 if (r->manufacturer_name) {
8455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8459                 }
8460                 if (r->manufacturer_url) {
8461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8464                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8465                 }
8466                 if (r->hardware_id) {
8467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8470                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8471                 }
8472                 if (r->provider) {
8473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8476                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8477                 }
8478         }
8479         return NDR_ERR_SUCCESS;
8480 }
8481
8482 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8483 {
8484         uint32_t _ptr_driver_name;
8485         TALLOC_CTX *_mem_save_driver_name_0;
8486         uint32_t _ptr_architecture;
8487         TALLOC_CTX *_mem_save_architecture_0;
8488         uint32_t _ptr_driver_path;
8489         TALLOC_CTX *_mem_save_driver_path_0;
8490         uint32_t _ptr_data_file;
8491         TALLOC_CTX *_mem_save_data_file_0;
8492         uint32_t _ptr_config_file;
8493         TALLOC_CTX *_mem_save_config_file_0;
8494         uint32_t _ptr_help_file;
8495         TALLOC_CTX *_mem_save_help_file_0;
8496         uint32_t _ptr_monitor_name;
8497         TALLOC_CTX *_mem_save_monitor_name_0;
8498         uint32_t _ptr_default_datatype;
8499         TALLOC_CTX *_mem_save_default_datatype_0;
8500         uint32_t _ptr_dependent_files;
8501         TALLOC_CTX *_mem_save_dependent_files_0;
8502         uint32_t _ptr_previous_names;
8503         TALLOC_CTX *_mem_save_previous_names_0;
8504         uint32_t _ptr_manufacturer_name;
8505         TALLOC_CTX *_mem_save_manufacturer_name_0;
8506         uint32_t _ptr_manufacturer_url;
8507         TALLOC_CTX *_mem_save_manufacturer_url_0;
8508         uint32_t _ptr_hardware_id;
8509         TALLOC_CTX *_mem_save_hardware_id_0;
8510         uint32_t _ptr_provider;
8511         TALLOC_CTX *_mem_save_provider_0;
8512         if (ndr_flags & NDR_SCALARS) {
8513                 NDR_CHECK(ndr_pull_align(ndr, 8));
8514                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8516                 if (_ptr_driver_name) {
8517                         NDR_PULL_ALLOC(ndr, r->driver_name);
8518                 } else {
8519                         r->driver_name = NULL;
8520                 }
8521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8522                 if (_ptr_architecture) {
8523                         NDR_PULL_ALLOC(ndr, r->architecture);
8524                 } else {
8525                         r->architecture = NULL;
8526                 }
8527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8528                 if (_ptr_driver_path) {
8529                         NDR_PULL_ALLOC(ndr, r->driver_path);
8530                 } else {
8531                         r->driver_path = NULL;
8532                 }
8533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8534                 if (_ptr_data_file) {
8535                         NDR_PULL_ALLOC(ndr, r->data_file);
8536                 } else {
8537                         r->data_file = NULL;
8538                 }
8539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8540                 if (_ptr_config_file) {
8541                         NDR_PULL_ALLOC(ndr, r->config_file);
8542                 } else {
8543                         r->config_file = NULL;
8544                 }
8545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8546                 if (_ptr_help_file) {
8547                         NDR_PULL_ALLOC(ndr, r->help_file);
8548                 } else {
8549                         r->help_file = NULL;
8550                 }
8551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8552                 if (_ptr_monitor_name) {
8553                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8554                 } else {
8555                         r->monitor_name = NULL;
8556                 }
8557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8558                 if (_ptr_default_datatype) {
8559                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8560                 } else {
8561                         r->default_datatype = NULL;
8562                 }
8563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8565                 if (_ptr_dependent_files) {
8566                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8567                 } else {
8568                         r->dependent_files = NULL;
8569                 }
8570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8571                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8572                 if (_ptr_previous_names) {
8573                         NDR_PULL_ALLOC(ndr, r->previous_names);
8574                 } else {
8575                         r->previous_names = NULL;
8576                 }
8577                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8578                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8580                 if (_ptr_manufacturer_name) {
8581                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8582                 } else {
8583                         r->manufacturer_name = NULL;
8584                 }
8585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8586                 if (_ptr_manufacturer_url) {
8587                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8588                 } else {
8589                         r->manufacturer_url = NULL;
8590                 }
8591                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8592                 if (_ptr_hardware_id) {
8593                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8594                 } else {
8595                         r->hardware_id = NULL;
8596                 }
8597                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8598                 if (_ptr_provider) {
8599                         NDR_PULL_ALLOC(ndr, r->provider);
8600                 } else {
8601                         r->provider = NULL;
8602                 }
8603         }
8604         if (ndr_flags & NDR_BUFFERS) {
8605                 if (r->driver_name) {
8606                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8607                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8610                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8611                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8612                         }
8613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8614                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8616                 }
8617                 if (r->architecture) {
8618                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8619                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8622                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8623                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8624                         }
8625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8628                 }
8629                 if (r->driver_path) {
8630                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8631                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8634                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8635                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8636                         }
8637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8640                 }
8641                 if (r->data_file) {
8642                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8643                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8644                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8645                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8646                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8647                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8648                         }
8649                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8650                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8652                 }
8653                 if (r->config_file) {
8654                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8655                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8658                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8659                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8660                         }
8661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8662                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8664                 }
8665                 if (r->help_file) {
8666                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8667                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8668                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8669                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8670                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8671                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8672                         }
8673                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8674                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8676                 }
8677                 if (r->monitor_name) {
8678                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8679                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8680                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8681                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8682                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8683                                 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));
8684                         }
8685                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8686                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8688                 }
8689                 if (r->default_datatype) {
8690                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8691                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8694                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8695                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8696                         }
8697                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8698                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8700                 }
8701                 if (r->dependent_files) {
8702                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8703                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8704                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8706                 }
8707                 if (r->previous_names) {
8708                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8709                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8710                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8712                 }
8713                 if (r->manufacturer_name) {
8714                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8715                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8718                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8719                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
8720                         }
8721                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8722                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8724                 }
8725                 if (r->manufacturer_url) {
8726                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8727                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8728                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8729                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8730                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8731                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
8732                         }
8733                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8734                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8736                 }
8737                 if (r->hardware_id) {
8738                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8739                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8740                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8741                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8742                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8743                                 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));
8744                         }
8745                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8746                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8748                 }
8749                 if (r->provider) {
8750                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8751                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8752                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8753                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8754                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8755                                 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));
8756                         }
8757                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8758                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8760                 }
8761         }
8762         return NDR_ERR_SUCCESS;
8763 }
8764
8765 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8766 {
8767         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8768         ndr->depth++;
8769         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8770         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8771         ndr->depth++;
8772         if (r->driver_name) {
8773                 ndr_print_string(ndr, "driver_name", r->driver_name);
8774         }
8775         ndr->depth--;
8776         ndr_print_ptr(ndr, "architecture", r->architecture);
8777         ndr->depth++;
8778         if (r->architecture) {
8779                 ndr_print_string(ndr, "architecture", r->architecture);
8780         }
8781         ndr->depth--;
8782         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8783         ndr->depth++;
8784         if (r->driver_path) {
8785                 ndr_print_string(ndr, "driver_path", r->driver_path);
8786         }
8787         ndr->depth--;
8788         ndr_print_ptr(ndr, "data_file", r->data_file);
8789         ndr->depth++;
8790         if (r->data_file) {
8791                 ndr_print_string(ndr, "data_file", r->data_file);
8792         }
8793         ndr->depth--;
8794         ndr_print_ptr(ndr, "config_file", r->config_file);
8795         ndr->depth++;
8796         if (r->config_file) {
8797                 ndr_print_string(ndr, "config_file", r->config_file);
8798         }
8799         ndr->depth--;
8800         ndr_print_ptr(ndr, "help_file", r->help_file);
8801         ndr->depth++;
8802         if (r->help_file) {
8803                 ndr_print_string(ndr, "help_file", r->help_file);
8804         }
8805         ndr->depth--;
8806         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8807         ndr->depth++;
8808         if (r->monitor_name) {
8809                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8810         }
8811         ndr->depth--;
8812         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8813         ndr->depth++;
8814         if (r->default_datatype) {
8815                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8816         }
8817         ndr->depth--;
8818         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);
8819         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8820         ndr->depth++;
8821         if (r->dependent_files) {
8822                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8823         }
8824         ndr->depth--;
8825         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);
8826         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8827         ndr->depth++;
8828         if (r->previous_names) {
8829                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8830         }
8831         ndr->depth--;
8832         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8833         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8834         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8835         ndr->depth++;
8836         if (r->manufacturer_name) {
8837                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8838         }
8839         ndr->depth--;
8840         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8841         ndr->depth++;
8842         if (r->manufacturer_url) {
8843                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8844         }
8845         ndr->depth--;
8846         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8847         ndr->depth++;
8848         if (r->hardware_id) {
8849                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8850         }
8851         ndr->depth--;
8852         ndr_print_ptr(ndr, "provider", r->provider);
8853         ndr->depth++;
8854         if (r->provider) {
8855                 ndr_print_string(ndr, "provider", r->provider);
8856         }
8857         ndr->depth--;
8858         ndr->depth--;
8859 }
8860
8861 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8862 {
8863         if (ndr_flags & NDR_SCALARS) {
8864                 NDR_CHECK(ndr_push_align(ndr, 8));
8865                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8866                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8867                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8871                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8872                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8873                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8875                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8877                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8878                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8879                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8880                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8881                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8882                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8884                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8892                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8893                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8894         }
8895         if (ndr_flags & NDR_BUFFERS) {
8896                 if (r->driver_name) {
8897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8901                 }
8902                 if (r->architecture) {
8903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8907                 }
8908                 if (r->driver_path) {
8909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8913                 }
8914                 if (r->data_file) {
8915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8919                 }
8920                 if (r->config_file) {
8921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8924                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8925                 }
8926                 if (r->help_file) {
8927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8931                 }
8932                 if (r->monitor_name) {
8933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8937                 }
8938                 if (r->default_datatype) {
8939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8940                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8941                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8942                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8943                 }
8944                 if (r->dependent_files) {
8945                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8946                 }
8947                 if (r->previous_names) {
8948                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8949                 }
8950                 if (r->manufacturer_name) {
8951                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8952                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8954                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8955                 }
8956                 if (r->manufacturer_url) {
8957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8960                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8961                 }
8962                 if (r->hardware_id) {
8963                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8964                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8966                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8967                 }
8968                 if (r->provider) {
8969                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8970                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8973                 }
8974                 if (r->print_processor) {
8975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8979                 }
8980                 if (r->vendor_setup) {
8981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8984                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8985                 }
8986                 if (r->color_profiles) {
8987                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8988                 }
8989                 if (r->inf_path) {
8990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8993                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8994                 }
8995                 if (r->core_driver_dependencies) {
8996                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8997                 }
8998         }
8999         return NDR_ERR_SUCCESS;
9000 }
9001
9002 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9003 {
9004         uint32_t _ptr_driver_name;
9005         TALLOC_CTX *_mem_save_driver_name_0;
9006         uint32_t _ptr_architecture;
9007         TALLOC_CTX *_mem_save_architecture_0;
9008         uint32_t _ptr_driver_path;
9009         TALLOC_CTX *_mem_save_driver_path_0;
9010         uint32_t _ptr_data_file;
9011         TALLOC_CTX *_mem_save_data_file_0;
9012         uint32_t _ptr_config_file;
9013         TALLOC_CTX *_mem_save_config_file_0;
9014         uint32_t _ptr_help_file;
9015         TALLOC_CTX *_mem_save_help_file_0;
9016         uint32_t _ptr_monitor_name;
9017         TALLOC_CTX *_mem_save_monitor_name_0;
9018         uint32_t _ptr_default_datatype;
9019         TALLOC_CTX *_mem_save_default_datatype_0;
9020         uint32_t _ptr_dependent_files;
9021         TALLOC_CTX *_mem_save_dependent_files_0;
9022         uint32_t _ptr_previous_names;
9023         TALLOC_CTX *_mem_save_previous_names_0;
9024         uint32_t _ptr_manufacturer_name;
9025         TALLOC_CTX *_mem_save_manufacturer_name_0;
9026         uint32_t _ptr_manufacturer_url;
9027         TALLOC_CTX *_mem_save_manufacturer_url_0;
9028         uint32_t _ptr_hardware_id;
9029         TALLOC_CTX *_mem_save_hardware_id_0;
9030         uint32_t _ptr_provider;
9031         TALLOC_CTX *_mem_save_provider_0;
9032         uint32_t _ptr_print_processor;
9033         TALLOC_CTX *_mem_save_print_processor_0;
9034         uint32_t _ptr_vendor_setup;
9035         TALLOC_CTX *_mem_save_vendor_setup_0;
9036         uint32_t _ptr_color_profiles;
9037         TALLOC_CTX *_mem_save_color_profiles_0;
9038         uint32_t _ptr_inf_path;
9039         TALLOC_CTX *_mem_save_inf_path_0;
9040         uint32_t _ptr_core_driver_dependencies;
9041         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9042         if (ndr_flags & NDR_SCALARS) {
9043                 NDR_CHECK(ndr_pull_align(ndr, 8));
9044                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9046                 if (_ptr_driver_name) {
9047                         NDR_PULL_ALLOC(ndr, r->driver_name);
9048                 } else {
9049                         r->driver_name = NULL;
9050                 }
9051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9052                 if (_ptr_architecture) {
9053                         NDR_PULL_ALLOC(ndr, r->architecture);
9054                 } else {
9055                         r->architecture = NULL;
9056                 }
9057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9058                 if (_ptr_driver_path) {
9059                         NDR_PULL_ALLOC(ndr, r->driver_path);
9060                 } else {
9061                         r->driver_path = NULL;
9062                 }
9063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9064                 if (_ptr_data_file) {
9065                         NDR_PULL_ALLOC(ndr, r->data_file);
9066                 } else {
9067                         r->data_file = NULL;
9068                 }
9069                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9070                 if (_ptr_config_file) {
9071                         NDR_PULL_ALLOC(ndr, r->config_file);
9072                 } else {
9073                         r->config_file = NULL;
9074                 }
9075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9076                 if (_ptr_help_file) {
9077                         NDR_PULL_ALLOC(ndr, r->help_file);
9078                 } else {
9079                         r->help_file = NULL;
9080                 }
9081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9082                 if (_ptr_monitor_name) {
9083                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9084                 } else {
9085                         r->monitor_name = NULL;
9086                 }
9087                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9088                 if (_ptr_default_datatype) {
9089                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9090                 } else {
9091                         r->default_datatype = NULL;
9092                 }
9093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9095                 if (_ptr_dependent_files) {
9096                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9097                 } else {
9098                         r->dependent_files = NULL;
9099                 }
9100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9102                 if (_ptr_previous_names) {
9103                         NDR_PULL_ALLOC(ndr, r->previous_names);
9104                 } else {
9105                         r->previous_names = NULL;
9106                 }
9107                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9108                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9110                 if (_ptr_manufacturer_name) {
9111                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9112                 } else {
9113                         r->manufacturer_name = NULL;
9114                 }
9115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9116                 if (_ptr_manufacturer_url) {
9117                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9118                 } else {
9119                         r->manufacturer_url = NULL;
9120                 }
9121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9122                 if (_ptr_hardware_id) {
9123                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9124                 } else {
9125                         r->hardware_id = NULL;
9126                 }
9127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9128                 if (_ptr_provider) {
9129                         NDR_PULL_ALLOC(ndr, r->provider);
9130                 } else {
9131                         r->provider = NULL;
9132                 }
9133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9134                 if (_ptr_print_processor) {
9135                         NDR_PULL_ALLOC(ndr, r->print_processor);
9136                 } else {
9137                         r->print_processor = NULL;
9138                 }
9139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9140                 if (_ptr_vendor_setup) {
9141                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9142                 } else {
9143                         r->vendor_setup = NULL;
9144                 }
9145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9147                 if (_ptr_color_profiles) {
9148                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9149                 } else {
9150                         r->color_profiles = NULL;
9151                 }
9152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9153                 if (_ptr_inf_path) {
9154                         NDR_PULL_ALLOC(ndr, r->inf_path);
9155                 } else {
9156                         r->inf_path = NULL;
9157                 }
9158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9161                 if (_ptr_core_driver_dependencies) {
9162                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9163                 } else {
9164                         r->core_driver_dependencies = NULL;
9165                 }
9166                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9167                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9168         }
9169         if (ndr_flags & NDR_BUFFERS) {
9170                 if (r->driver_name) {
9171                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9172                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9175                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9176                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9177                         }
9178                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9179                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9181                 }
9182                 if (r->architecture) {
9183                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9184                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9187                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9188                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9189                         }
9190                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9191                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9193                 }
9194                 if (r->driver_path) {
9195                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9196                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9197                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9198                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9199                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9200                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9201                         }
9202                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9203                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9205                 }
9206                 if (r->data_file) {
9207                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9208                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9210                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9211                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9212                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9213                         }
9214                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9215                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9217                 }
9218                 if (r->config_file) {
9219                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9220                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9221                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9222                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9223                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9224                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9225                         }
9226                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9227                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9229                 }
9230                 if (r->help_file) {
9231                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9232                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9234                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9235                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9236                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9237                         }
9238                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9239                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9241                 }
9242                 if (r->monitor_name) {
9243                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9246                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9247                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9248                                 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));
9249                         }
9250                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9251                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9253                 }
9254                 if (r->default_datatype) {
9255                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9256                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9259                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9260                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9261                         }
9262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9263                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9265                 }
9266                 if (r->dependent_files) {
9267                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9268                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9269                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9271                 }
9272                 if (r->previous_names) {
9273                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9274                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9275                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9277                 }
9278                 if (r->manufacturer_name) {
9279                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9280                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9283                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9284                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9285                         }
9286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9289                 }
9290                 if (r->manufacturer_url) {
9291                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9292                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9295                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9296                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9297                         }
9298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9301                 }
9302                 if (r->hardware_id) {
9303                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9304                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9307                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9308                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9309                         }
9310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9313                 }
9314                 if (r->provider) {
9315                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9316                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9319                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9320                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9321                         }
9322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9325                 }
9326                 if (r->print_processor) {
9327                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9328                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9331                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9332                                 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));
9333                         }
9334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9337                 }
9338                 if (r->vendor_setup) {
9339                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9340                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9343                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9344                                 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));
9345                         }
9346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9349                 }
9350                 if (r->color_profiles) {
9351                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9352                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9353                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9355                 }
9356                 if (r->inf_path) {
9357                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9358                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9359                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9360                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9361                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9362                                 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));
9363                         }
9364                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9365                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9366                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9367                 }
9368                 if (r->core_driver_dependencies) {
9369                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9370                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9371                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9373                 }
9374         }
9375         return NDR_ERR_SUCCESS;
9376 }
9377
9378 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9379 {
9380         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9381         ndr->depth++;
9382         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9383         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9384         ndr->depth++;
9385         if (r->driver_name) {
9386                 ndr_print_string(ndr, "driver_name", r->driver_name);
9387         }
9388         ndr->depth--;
9389         ndr_print_ptr(ndr, "architecture", r->architecture);
9390         ndr->depth++;
9391         if (r->architecture) {
9392                 ndr_print_string(ndr, "architecture", r->architecture);
9393         }
9394         ndr->depth--;
9395         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9396         ndr->depth++;
9397         if (r->driver_path) {
9398                 ndr_print_string(ndr, "driver_path", r->driver_path);
9399         }
9400         ndr->depth--;
9401         ndr_print_ptr(ndr, "data_file", r->data_file);
9402         ndr->depth++;
9403         if (r->data_file) {
9404                 ndr_print_string(ndr, "data_file", r->data_file);
9405         }
9406         ndr->depth--;
9407         ndr_print_ptr(ndr, "config_file", r->config_file);
9408         ndr->depth++;
9409         if (r->config_file) {
9410                 ndr_print_string(ndr, "config_file", r->config_file);
9411         }
9412         ndr->depth--;
9413         ndr_print_ptr(ndr, "help_file", r->help_file);
9414         ndr->depth++;
9415         if (r->help_file) {
9416                 ndr_print_string(ndr, "help_file", r->help_file);
9417         }
9418         ndr->depth--;
9419         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9420         ndr->depth++;
9421         if (r->monitor_name) {
9422                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9423         }
9424         ndr->depth--;
9425         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9426         ndr->depth++;
9427         if (r->default_datatype) {
9428                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9429         }
9430         ndr->depth--;
9431         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);
9432         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9433         ndr->depth++;
9434         if (r->dependent_files) {
9435                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9436         }
9437         ndr->depth--;
9438         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);
9439         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9440         ndr->depth++;
9441         if (r->previous_names) {
9442                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9443         }
9444         ndr->depth--;
9445         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9446         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9447         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9448         ndr->depth++;
9449         if (r->manufacturer_name) {
9450                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9451         }
9452         ndr->depth--;
9453         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9454         ndr->depth++;
9455         if (r->manufacturer_url) {
9456                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9457         }
9458         ndr->depth--;
9459         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9460         ndr->depth++;
9461         if (r->hardware_id) {
9462                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9463         }
9464         ndr->depth--;
9465         ndr_print_ptr(ndr, "provider", r->provider);
9466         ndr->depth++;
9467         if (r->provider) {
9468                 ndr_print_string(ndr, "provider", r->provider);
9469         }
9470         ndr->depth--;
9471         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9472         ndr->depth++;
9473         if (r->print_processor) {
9474                 ndr_print_string(ndr, "print_processor", r->print_processor);
9475         }
9476         ndr->depth--;
9477         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9478         ndr->depth++;
9479         if (r->vendor_setup) {
9480                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9481         }
9482         ndr->depth--;
9483         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);
9484         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9485         ndr->depth++;
9486         if (r->color_profiles) {
9487                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9488         }
9489         ndr->depth--;
9490         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9491         ndr->depth++;
9492         if (r->inf_path) {
9493                 ndr_print_string(ndr, "inf_path", r->inf_path);
9494         }
9495         ndr->depth--;
9496         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9497         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);
9498         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9499         ndr->depth++;
9500         if (r->core_driver_dependencies) {
9501                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9502         }
9503         ndr->depth--;
9504         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9505         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9506         ndr->depth--;
9507 }
9508
9509 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9510 {
9511         if (ndr_flags & NDR_SCALARS) {
9512                 int level = ndr_push_get_switch_value(ndr, r);
9513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9514                 switch (level) {
9515                         case 1: {
9516                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9517                         break; }
9518
9519                         case 2: {
9520                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9521                         break; }
9522
9523                         case 3: {
9524                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9525                         break; }
9526
9527                         case 4: {
9528                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9529                         break; }
9530
9531                         case 6: {
9532                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9533                         break; }
9534
9535                         case 8: {
9536                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9537                         break; }
9538
9539                         default:
9540                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9541                 }
9542         }
9543         if (ndr_flags & NDR_BUFFERS) {
9544                 int level = ndr_push_get_switch_value(ndr, r);
9545                 switch (level) {
9546                         case 1:
9547                                 if (r->info1) {
9548                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9549                                 }
9550                         break;
9551
9552                         case 2:
9553                                 if (r->info2) {
9554                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9555                                 }
9556                         break;
9557
9558                         case 3:
9559                                 if (r->info3) {
9560                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9561                                 }
9562                         break;
9563
9564                         case 4:
9565                                 if (r->info4) {
9566                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9567                                 }
9568                         break;
9569
9570                         case 6:
9571                                 if (r->info6) {
9572                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9573                                 }
9574                         break;
9575
9576                         case 8:
9577                                 if (r->info8) {
9578                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9579                                 }
9580                         break;
9581
9582                         default:
9583                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9584                 }
9585         }
9586         return NDR_ERR_SUCCESS;
9587 }
9588
9589 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9590 {
9591         int level;
9592         uint32_t _level;
9593         TALLOC_CTX *_mem_save_info1_0;
9594         TALLOC_CTX *_mem_save_info2_0;
9595         TALLOC_CTX *_mem_save_info3_0;
9596         TALLOC_CTX *_mem_save_info4_0;
9597         TALLOC_CTX *_mem_save_info6_0;
9598         TALLOC_CTX *_mem_save_info8_0;
9599         level = ndr_pull_get_switch_value(ndr, r);
9600         if (ndr_flags & NDR_SCALARS) {
9601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9602                 if (_level != level) {
9603                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9604                 }
9605                 switch (level) {
9606                         case 1: {
9607                                 uint32_t _ptr_info1;
9608                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9609                                 if (_ptr_info1) {
9610                                         NDR_PULL_ALLOC(ndr, r->info1);
9611                                 } else {
9612                                         r->info1 = NULL;
9613                                 }
9614                         break; }
9615
9616                         case 2: {
9617                                 uint32_t _ptr_info2;
9618                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9619                                 if (_ptr_info2) {
9620                                         NDR_PULL_ALLOC(ndr, r->info2);
9621                                 } else {
9622                                         r->info2 = NULL;
9623                                 }
9624                         break; }
9625
9626                         case 3: {
9627                                 uint32_t _ptr_info3;
9628                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9629                                 if (_ptr_info3) {
9630                                         NDR_PULL_ALLOC(ndr, r->info3);
9631                                 } else {
9632                                         r->info3 = NULL;
9633                                 }
9634                         break; }
9635
9636                         case 4: {
9637                                 uint32_t _ptr_info4;
9638                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9639                                 if (_ptr_info4) {
9640                                         NDR_PULL_ALLOC(ndr, r->info4);
9641                                 } else {
9642                                         r->info4 = NULL;
9643                                 }
9644                         break; }
9645
9646                         case 6: {
9647                                 uint32_t _ptr_info6;
9648                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9649                                 if (_ptr_info6) {
9650                                         NDR_PULL_ALLOC(ndr, r->info6);
9651                                 } else {
9652                                         r->info6 = NULL;
9653                                 }
9654                         break; }
9655
9656                         case 8: {
9657                                 uint32_t _ptr_info8;
9658                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9659                                 if (_ptr_info8) {
9660                                         NDR_PULL_ALLOC(ndr, r->info8);
9661                                 } else {
9662                                         r->info8 = NULL;
9663                                 }
9664                         break; }
9665
9666                         default:
9667                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9668                 }
9669         }
9670         if (ndr_flags & NDR_BUFFERS) {
9671                 switch (level) {
9672                         case 1:
9673                                 if (r->info1) {
9674                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9675                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9676                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9677                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9678                                 }
9679                         break;
9680
9681                         case 2:
9682                                 if (r->info2) {
9683                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9684                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9685                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9686                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9687                                 }
9688                         break;
9689
9690                         case 3:
9691                                 if (r->info3) {
9692                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9693                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9694                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9695                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9696                                 }
9697                         break;
9698
9699                         case 4:
9700                                 if (r->info4) {
9701                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9702                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9703                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9704                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9705                                 }
9706                         break;
9707
9708                         case 6:
9709                                 if (r->info6) {
9710                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9711                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9712                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9713                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9714                                 }
9715                         break;
9716
9717                         case 8:
9718                                 if (r->info8) {
9719                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9720                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9721                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9722                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9723                                 }
9724                         break;
9725
9726                         default:
9727                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9728                 }
9729         }
9730         return NDR_ERR_SUCCESS;
9731 }
9732
9733 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9734 {
9735         int level;
9736         level = ndr_print_get_switch_value(ndr, r);
9737         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9738         switch (level) {
9739                 case 1:
9740                         ndr_print_ptr(ndr, "info1", r->info1);
9741                         ndr->depth++;
9742                         if (r->info1) {
9743                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9744                         }
9745                         ndr->depth--;
9746                 break;
9747
9748                 case 2:
9749                         ndr_print_ptr(ndr, "info2", r->info2);
9750                         ndr->depth++;
9751                         if (r->info2) {
9752                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9753                         }
9754                         ndr->depth--;
9755                 break;
9756
9757                 case 3:
9758                         ndr_print_ptr(ndr, "info3", r->info3);
9759                         ndr->depth++;
9760                         if (r->info3) {
9761                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9762                         }
9763                         ndr->depth--;
9764                 break;
9765
9766                 case 4:
9767                         ndr_print_ptr(ndr, "info4", r->info4);
9768                         ndr->depth++;
9769                         if (r->info4) {
9770                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9771                         }
9772                         ndr->depth--;
9773                 break;
9774
9775                 case 6:
9776                         ndr_print_ptr(ndr, "info6", r->info6);
9777                         ndr->depth++;
9778                         if (r->info6) {
9779                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9780                         }
9781                         ndr->depth--;
9782                 break;
9783
9784                 case 8:
9785                         ndr_print_ptr(ndr, "info8", r->info8);
9786                         ndr->depth++;
9787                         if (r->info8) {
9788                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9789                         }
9790                         ndr->depth--;
9791                 break;
9792
9793                 default:
9794                         ndr_print_bad_level(ndr, name, level);
9795         }
9796 }
9797
9798 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9799 {
9800         if (ndr_flags & NDR_SCALARS) {
9801                 NDR_CHECK(ndr_push_align(ndr, 4));
9802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9803                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9804                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9805         }
9806         if (ndr_flags & NDR_BUFFERS) {
9807                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9808         }
9809         return NDR_ERR_SUCCESS;
9810 }
9811
9812 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9813 {
9814         if (ndr_flags & NDR_SCALARS) {
9815                 NDR_CHECK(ndr_pull_align(ndr, 4));
9816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9817                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9818                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9819         }
9820         if (ndr_flags & NDR_BUFFERS) {
9821                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9822         }
9823         return NDR_ERR_SUCCESS;
9824 }
9825
9826 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9827 {
9828         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9829         ndr->depth++;
9830         ndr_print_uint32(ndr, "level", r->level);
9831         ndr_print_set_switch_value(ndr, &r->info, r->level);
9832         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9833         ndr->depth--;
9834 }
9835
9836 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9837 {
9838         if (ndr_flags & NDR_SCALARS) {
9839                 NDR_CHECK(ndr_push_align(ndr, 4));
9840                 {
9841                         uint32_t _flags_save_string = ndr->flags;
9842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9843                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9844                         ndr->flags = _flags_save_string;
9845                 }
9846         }
9847         if (ndr_flags & NDR_BUFFERS) {
9848                 {
9849                         uint32_t _flags_save_string = ndr->flags;
9850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9851                         if (r->driver_name) {
9852                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9853                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9854                         }
9855                         ndr->flags = _flags_save_string;
9856                 }
9857         }
9858         return NDR_ERR_SUCCESS;
9859 }
9860
9861 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9862 {
9863         uint32_t _ptr_driver_name;
9864         TALLOC_CTX *_mem_save_driver_name_0;
9865         if (ndr_flags & NDR_SCALARS) {
9866                 NDR_CHECK(ndr_pull_align(ndr, 4));
9867                 {
9868                         uint32_t _flags_save_string = ndr->flags;
9869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9870                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9871                         if (_ptr_driver_name) {
9872                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9873                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9874                         } else {
9875                                 r->driver_name = NULL;
9876                         }
9877                         ndr->flags = _flags_save_string;
9878                 }
9879         }
9880         if (ndr_flags & NDR_BUFFERS) {
9881                 {
9882                         uint32_t _flags_save_string = ndr->flags;
9883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9884                         if (r->driver_name) {
9885                                 uint32_t _relative_save_offset;
9886                                 _relative_save_offset = ndr->offset;
9887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9888                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9889                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9892                                 ndr->offset = _relative_save_offset;
9893                         }
9894                         ndr->flags = _flags_save_string;
9895                 }
9896         }
9897         return NDR_ERR_SUCCESS;
9898 }
9899
9900 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9901 {
9902         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9903         ndr->depth++;
9904         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9905         ndr->depth++;
9906         if (r->driver_name) {
9907                 ndr_print_string(ndr, "driver_name", r->driver_name);
9908         }
9909         ndr->depth--;
9910         ndr->depth--;
9911 }
9912
9913 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9914 {
9915         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9916 }
9917
9918 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9919 {
9920         if (ndr_flags & NDR_SCALARS) {
9921                 NDR_CHECK(ndr_push_align(ndr, 4));
9922                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9923                 {
9924                         uint32_t _flags_save_string = ndr->flags;
9925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9926                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9927                         ndr->flags = _flags_save_string;
9928                 }
9929                 {
9930                         uint32_t _flags_save_string = ndr->flags;
9931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9932                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9933                         ndr->flags = _flags_save_string;
9934                 }
9935                 {
9936                         uint32_t _flags_save_string = ndr->flags;
9937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9938                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9939                         ndr->flags = _flags_save_string;
9940                 }
9941                 {
9942                         uint32_t _flags_save_string = ndr->flags;
9943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9944                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9945                         ndr->flags = _flags_save_string;
9946                 }
9947                 {
9948                         uint32_t _flags_save_string = ndr->flags;
9949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9950                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9951                         ndr->flags = _flags_save_string;
9952                 }
9953         }
9954         if (ndr_flags & NDR_BUFFERS) {
9955                 {
9956                         uint32_t _flags_save_string = ndr->flags;
9957                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9958                         if (r->driver_name) {
9959                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9960                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9961                         }
9962                         ndr->flags = _flags_save_string;
9963                 }
9964                 {
9965                         uint32_t _flags_save_string = ndr->flags;
9966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9967                         if (r->architecture) {
9968                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9969                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9970                         }
9971                         ndr->flags = _flags_save_string;
9972                 }
9973                 {
9974                         uint32_t _flags_save_string = ndr->flags;
9975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9976                         if (r->driver_path) {
9977                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9978                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9979                         }
9980                         ndr->flags = _flags_save_string;
9981                 }
9982                 {
9983                         uint32_t _flags_save_string = ndr->flags;
9984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9985                         if (r->data_file) {
9986                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9987                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9988                         }
9989                         ndr->flags = _flags_save_string;
9990                 }
9991                 {
9992                         uint32_t _flags_save_string = ndr->flags;
9993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9994                         if (r->config_file) {
9995                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9996                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9997                         }
9998                         ndr->flags = _flags_save_string;
9999                 }
10000         }
10001         return NDR_ERR_SUCCESS;
10002 }
10003
10004 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10005 {
10006         uint32_t _ptr_driver_name;
10007         TALLOC_CTX *_mem_save_driver_name_0;
10008         uint32_t _ptr_architecture;
10009         TALLOC_CTX *_mem_save_architecture_0;
10010         uint32_t _ptr_driver_path;
10011         TALLOC_CTX *_mem_save_driver_path_0;
10012         uint32_t _ptr_data_file;
10013         TALLOC_CTX *_mem_save_data_file_0;
10014         uint32_t _ptr_config_file;
10015         TALLOC_CTX *_mem_save_config_file_0;
10016         if (ndr_flags & NDR_SCALARS) {
10017                 NDR_CHECK(ndr_pull_align(ndr, 4));
10018                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10019                 {
10020                         uint32_t _flags_save_string = ndr->flags;
10021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10022                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10023                         if (_ptr_driver_name) {
10024                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10025                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10026                         } else {
10027                                 r->driver_name = NULL;
10028                         }
10029                         ndr->flags = _flags_save_string;
10030                 }
10031                 {
10032                         uint32_t _flags_save_string = ndr->flags;
10033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10034                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10035                         if (_ptr_architecture) {
10036                                 NDR_PULL_ALLOC(ndr, r->architecture);
10037                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10038                         } else {
10039                                 r->architecture = NULL;
10040                         }
10041                         ndr->flags = _flags_save_string;
10042                 }
10043                 {
10044                         uint32_t _flags_save_string = ndr->flags;
10045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10046                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10047                         if (_ptr_driver_path) {
10048                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10049                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10050                         } else {
10051                                 r->driver_path = NULL;
10052                         }
10053                         ndr->flags = _flags_save_string;
10054                 }
10055                 {
10056                         uint32_t _flags_save_string = ndr->flags;
10057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10058                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10059                         if (_ptr_data_file) {
10060                                 NDR_PULL_ALLOC(ndr, r->data_file);
10061                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10062                         } else {
10063                                 r->data_file = NULL;
10064                         }
10065                         ndr->flags = _flags_save_string;
10066                 }
10067                 {
10068                         uint32_t _flags_save_string = ndr->flags;
10069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10070                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10071                         if (_ptr_config_file) {
10072                                 NDR_PULL_ALLOC(ndr, r->config_file);
10073                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10074                         } else {
10075                                 r->config_file = NULL;
10076                         }
10077                         ndr->flags = _flags_save_string;
10078                 }
10079         }
10080         if (ndr_flags & NDR_BUFFERS) {
10081                 {
10082                         uint32_t _flags_save_string = ndr->flags;
10083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10084                         if (r->driver_name) {
10085                                 uint32_t _relative_save_offset;
10086                                 _relative_save_offset = ndr->offset;
10087                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10088                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10089                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10090                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10091                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10092                                 ndr->offset = _relative_save_offset;
10093                         }
10094                         ndr->flags = _flags_save_string;
10095                 }
10096                 {
10097                         uint32_t _flags_save_string = ndr->flags;
10098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10099                         if (r->architecture) {
10100                                 uint32_t _relative_save_offset;
10101                                 _relative_save_offset = ndr->offset;
10102                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10103                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10104                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10105                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10106                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10107                                 ndr->offset = _relative_save_offset;
10108                         }
10109                         ndr->flags = _flags_save_string;
10110                 }
10111                 {
10112                         uint32_t _flags_save_string = ndr->flags;
10113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10114                         if (r->driver_path) {
10115                                 uint32_t _relative_save_offset;
10116                                 _relative_save_offset = ndr->offset;
10117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10118                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10119                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10120                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10122                                 ndr->offset = _relative_save_offset;
10123                         }
10124                         ndr->flags = _flags_save_string;
10125                 }
10126                 {
10127                         uint32_t _flags_save_string = ndr->flags;
10128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10129                         if (r->data_file) {
10130                                 uint32_t _relative_save_offset;
10131                                 _relative_save_offset = ndr->offset;
10132                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10133                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10134                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10135                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10136                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10137                                 ndr->offset = _relative_save_offset;
10138                         }
10139                         ndr->flags = _flags_save_string;
10140                 }
10141                 {
10142                         uint32_t _flags_save_string = ndr->flags;
10143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10144                         if (r->config_file) {
10145                                 uint32_t _relative_save_offset;
10146                                 _relative_save_offset = ndr->offset;
10147                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10148                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10149                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10150                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10151                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10152                                 ndr->offset = _relative_save_offset;
10153                         }
10154                         ndr->flags = _flags_save_string;
10155                 }
10156         }
10157         return NDR_ERR_SUCCESS;
10158 }
10159
10160 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10161 {
10162         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10163         ndr->depth++;
10164         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10165         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10166         ndr->depth++;
10167         if (r->driver_name) {
10168                 ndr_print_string(ndr, "driver_name", r->driver_name);
10169         }
10170         ndr->depth--;
10171         ndr_print_ptr(ndr, "architecture", r->architecture);
10172         ndr->depth++;
10173         if (r->architecture) {
10174                 ndr_print_string(ndr, "architecture", r->architecture);
10175         }
10176         ndr->depth--;
10177         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10178         ndr->depth++;
10179         if (r->driver_path) {
10180                 ndr_print_string(ndr, "driver_path", r->driver_path);
10181         }
10182         ndr->depth--;
10183         ndr_print_ptr(ndr, "data_file", r->data_file);
10184         ndr->depth++;
10185         if (r->data_file) {
10186                 ndr_print_string(ndr, "data_file", r->data_file);
10187         }
10188         ndr->depth--;
10189         ndr_print_ptr(ndr, "config_file", r->config_file);
10190         ndr->depth++;
10191         if (r->config_file) {
10192                 ndr_print_string(ndr, "config_file", r->config_file);
10193         }
10194         ndr->depth--;
10195         ndr->depth--;
10196 }
10197
10198 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10199 {
10200         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10201 }
10202
10203 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10204 {
10205         if (ndr_flags & NDR_SCALARS) {
10206                 NDR_CHECK(ndr_push_align(ndr, 4));
10207                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10208                 {
10209                         uint32_t _flags_save_string = ndr->flags;
10210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10211                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10212                         ndr->flags = _flags_save_string;
10213                 }
10214                 {
10215                         uint32_t _flags_save_string = ndr->flags;
10216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10217                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10218                         ndr->flags = _flags_save_string;
10219                 }
10220                 {
10221                         uint32_t _flags_save_string = ndr->flags;
10222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10223                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10224                         ndr->flags = _flags_save_string;
10225                 }
10226                 {
10227                         uint32_t _flags_save_string = ndr->flags;
10228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10229                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10230                         ndr->flags = _flags_save_string;
10231                 }
10232                 {
10233                         uint32_t _flags_save_string = ndr->flags;
10234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10235                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10236                         ndr->flags = _flags_save_string;
10237                 }
10238                 {
10239                         uint32_t _flags_save_string = ndr->flags;
10240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10242                         ndr->flags = _flags_save_string;
10243                 }
10244                 {
10245                         uint32_t _flags_save_string_array = ndr->flags;
10246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10247                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10248                         ndr->flags = _flags_save_string_array;
10249                 }
10250                 {
10251                         uint32_t _flags_save_string = ndr->flags;
10252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10253                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10254                         ndr->flags = _flags_save_string;
10255                 }
10256                 {
10257                         uint32_t _flags_save_string = ndr->flags;
10258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10260                         ndr->flags = _flags_save_string;
10261                 }
10262         }
10263         if (ndr_flags & NDR_BUFFERS) {
10264                 {
10265                         uint32_t _flags_save_string = ndr->flags;
10266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10267                         if (r->driver_name) {
10268                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10269                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10270                         }
10271                         ndr->flags = _flags_save_string;
10272                 }
10273                 {
10274                         uint32_t _flags_save_string = ndr->flags;
10275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10276                         if (r->architecture) {
10277                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10278                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10279                         }
10280                         ndr->flags = _flags_save_string;
10281                 }
10282                 {
10283                         uint32_t _flags_save_string = ndr->flags;
10284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10285                         if (r->driver_path) {
10286                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10287                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10288                         }
10289                         ndr->flags = _flags_save_string;
10290                 }
10291                 {
10292                         uint32_t _flags_save_string = ndr->flags;
10293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10294                         if (r->data_file) {
10295                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10296                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10297                         }
10298                         ndr->flags = _flags_save_string;
10299                 }
10300                 {
10301                         uint32_t _flags_save_string = ndr->flags;
10302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10303                         if (r->config_file) {
10304                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10305                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10306                         }
10307                         ndr->flags = _flags_save_string;
10308                 }
10309                 {
10310                         uint32_t _flags_save_string = ndr->flags;
10311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10312                         if (r->help_file) {
10313                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10315                         }
10316                         ndr->flags = _flags_save_string;
10317                 }
10318                 {
10319                         uint32_t _flags_save_string_array = ndr->flags;
10320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10321                         if (r->dependent_files) {
10322                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10323                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10324                         }
10325                         ndr->flags = _flags_save_string_array;
10326                 }
10327                 {
10328                         uint32_t _flags_save_string = ndr->flags;
10329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10330                         if (r->monitor_name) {
10331                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10332                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10333                         }
10334                         ndr->flags = _flags_save_string;
10335                 }
10336                 {
10337                         uint32_t _flags_save_string = ndr->flags;
10338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10339                         if (r->default_datatype) {
10340                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10341                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10342                         }
10343                         ndr->flags = _flags_save_string;
10344                 }
10345         }
10346         return NDR_ERR_SUCCESS;
10347 }
10348
10349 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10350 {
10351         uint32_t _ptr_driver_name;
10352         TALLOC_CTX *_mem_save_driver_name_0;
10353         uint32_t _ptr_architecture;
10354         TALLOC_CTX *_mem_save_architecture_0;
10355         uint32_t _ptr_driver_path;
10356         TALLOC_CTX *_mem_save_driver_path_0;
10357         uint32_t _ptr_data_file;
10358         TALLOC_CTX *_mem_save_data_file_0;
10359         uint32_t _ptr_config_file;
10360         TALLOC_CTX *_mem_save_config_file_0;
10361         uint32_t _ptr_help_file;
10362         TALLOC_CTX *_mem_save_help_file_0;
10363         uint32_t _ptr_dependent_files;
10364         TALLOC_CTX *_mem_save_dependent_files_0;
10365         uint32_t _ptr_monitor_name;
10366         TALLOC_CTX *_mem_save_monitor_name_0;
10367         uint32_t _ptr_default_datatype;
10368         TALLOC_CTX *_mem_save_default_datatype_0;
10369         if (ndr_flags & NDR_SCALARS) {
10370                 NDR_CHECK(ndr_pull_align(ndr, 4));
10371                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10372                 {
10373                         uint32_t _flags_save_string = ndr->flags;
10374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10375                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10376                         if (_ptr_driver_name) {
10377                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10379                         } else {
10380                                 r->driver_name = NULL;
10381                         }
10382                         ndr->flags = _flags_save_string;
10383                 }
10384                 {
10385                         uint32_t _flags_save_string = ndr->flags;
10386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10387                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10388                         if (_ptr_architecture) {
10389                                 NDR_PULL_ALLOC(ndr, r->architecture);
10390                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10391                         } else {
10392                                 r->architecture = NULL;
10393                         }
10394                         ndr->flags = _flags_save_string;
10395                 }
10396                 {
10397                         uint32_t _flags_save_string = ndr->flags;
10398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10399                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10400                         if (_ptr_driver_path) {
10401                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10402                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10403                         } else {
10404                                 r->driver_path = NULL;
10405                         }
10406                         ndr->flags = _flags_save_string;
10407                 }
10408                 {
10409                         uint32_t _flags_save_string = ndr->flags;
10410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10411                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10412                         if (_ptr_data_file) {
10413                                 NDR_PULL_ALLOC(ndr, r->data_file);
10414                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10415                         } else {
10416                                 r->data_file = NULL;
10417                         }
10418                         ndr->flags = _flags_save_string;
10419                 }
10420                 {
10421                         uint32_t _flags_save_string = ndr->flags;
10422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10423                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10424                         if (_ptr_config_file) {
10425                                 NDR_PULL_ALLOC(ndr, r->config_file);
10426                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10427                         } else {
10428                                 r->config_file = NULL;
10429                         }
10430                         ndr->flags = _flags_save_string;
10431                 }
10432                 {
10433                         uint32_t _flags_save_string = ndr->flags;
10434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10435                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10436                         if (_ptr_help_file) {
10437                                 NDR_PULL_ALLOC(ndr, r->help_file);
10438                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10439                         } else {
10440                                 r->help_file = NULL;
10441                         }
10442                         ndr->flags = _flags_save_string;
10443                 }
10444                 {
10445                         uint32_t _flags_save_string_array = ndr->flags;
10446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10447                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10448                         if (_ptr_dependent_files) {
10449                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10450                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10451                         } else {
10452                                 r->dependent_files = NULL;
10453                         }
10454                         ndr->flags = _flags_save_string_array;
10455                 }
10456                 {
10457                         uint32_t _flags_save_string = ndr->flags;
10458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10459                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10460                         if (_ptr_monitor_name) {
10461                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10462                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10463                         } else {
10464                                 r->monitor_name = NULL;
10465                         }
10466                         ndr->flags = _flags_save_string;
10467                 }
10468                 {
10469                         uint32_t _flags_save_string = ndr->flags;
10470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10471                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10472                         if (_ptr_default_datatype) {
10473                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10474                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10475                         } else {
10476                                 r->default_datatype = NULL;
10477                         }
10478                         ndr->flags = _flags_save_string;
10479                 }
10480         }
10481         if (ndr_flags & NDR_BUFFERS) {
10482                 {
10483                         uint32_t _flags_save_string = ndr->flags;
10484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10485                         if (r->driver_name) {
10486                                 uint32_t _relative_save_offset;
10487                                 _relative_save_offset = ndr->offset;
10488                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10489                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10490                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10491                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10492                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10493                                 ndr->offset = _relative_save_offset;
10494                         }
10495                         ndr->flags = _flags_save_string;
10496                 }
10497                 {
10498                         uint32_t _flags_save_string = ndr->flags;
10499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10500                         if (r->architecture) {
10501                                 uint32_t _relative_save_offset;
10502                                 _relative_save_offset = ndr->offset;
10503                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10504                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10505                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10506                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10507                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10508                                 ndr->offset = _relative_save_offset;
10509                         }
10510                         ndr->flags = _flags_save_string;
10511                 }
10512                 {
10513                         uint32_t _flags_save_string = ndr->flags;
10514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10515                         if (r->driver_path) {
10516                                 uint32_t _relative_save_offset;
10517                                 _relative_save_offset = ndr->offset;
10518                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10519                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10520                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10521                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10522                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10523                                 ndr->offset = _relative_save_offset;
10524                         }
10525                         ndr->flags = _flags_save_string;
10526                 }
10527                 {
10528                         uint32_t _flags_save_string = ndr->flags;
10529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10530                         if (r->data_file) {
10531                                 uint32_t _relative_save_offset;
10532                                 _relative_save_offset = ndr->offset;
10533                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10534                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10535                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10536                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10537                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10538                                 ndr->offset = _relative_save_offset;
10539                         }
10540                         ndr->flags = _flags_save_string;
10541                 }
10542                 {
10543                         uint32_t _flags_save_string = ndr->flags;
10544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10545                         if (r->config_file) {
10546                                 uint32_t _relative_save_offset;
10547                                 _relative_save_offset = ndr->offset;
10548                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10549                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10550                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10551                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10552                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10553                                 ndr->offset = _relative_save_offset;
10554                         }
10555                         ndr->flags = _flags_save_string;
10556                 }
10557                 {
10558                         uint32_t _flags_save_string = ndr->flags;
10559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10560                         if (r->help_file) {
10561                                 uint32_t _relative_save_offset;
10562                                 _relative_save_offset = ndr->offset;
10563                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10564                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10565                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10566                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10567                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10568                                 ndr->offset = _relative_save_offset;
10569                         }
10570                         ndr->flags = _flags_save_string;
10571                 }
10572                 {
10573                         uint32_t _flags_save_string_array = ndr->flags;
10574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10575                         if (r->dependent_files) {
10576                                 uint32_t _relative_save_offset;
10577                                 _relative_save_offset = ndr->offset;
10578                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10579                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10580                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10581                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10582                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10583                                 ndr->offset = _relative_save_offset;
10584                         }
10585                         ndr->flags = _flags_save_string_array;
10586                 }
10587                 {
10588                         uint32_t _flags_save_string = ndr->flags;
10589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10590                         if (r->monitor_name) {
10591                                 uint32_t _relative_save_offset;
10592                                 _relative_save_offset = ndr->offset;
10593                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10594                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10595                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10596                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10597                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10598                                 ndr->offset = _relative_save_offset;
10599                         }
10600                         ndr->flags = _flags_save_string;
10601                 }
10602                 {
10603                         uint32_t _flags_save_string = ndr->flags;
10604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10605                         if (r->default_datatype) {
10606                                 uint32_t _relative_save_offset;
10607                                 _relative_save_offset = ndr->offset;
10608                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10609                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10610                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10613                                 ndr->offset = _relative_save_offset;
10614                         }
10615                         ndr->flags = _flags_save_string;
10616                 }
10617         }
10618         return NDR_ERR_SUCCESS;
10619 }
10620
10621 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10622 {
10623         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10624         ndr->depth++;
10625         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10626         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10627         ndr->depth++;
10628         if (r->driver_name) {
10629                 ndr_print_string(ndr, "driver_name", r->driver_name);
10630         }
10631         ndr->depth--;
10632         ndr_print_ptr(ndr, "architecture", r->architecture);
10633         ndr->depth++;
10634         if (r->architecture) {
10635                 ndr_print_string(ndr, "architecture", r->architecture);
10636         }
10637         ndr->depth--;
10638         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10639         ndr->depth++;
10640         if (r->driver_path) {
10641                 ndr_print_string(ndr, "driver_path", r->driver_path);
10642         }
10643         ndr->depth--;
10644         ndr_print_ptr(ndr, "data_file", r->data_file);
10645         ndr->depth++;
10646         if (r->data_file) {
10647                 ndr_print_string(ndr, "data_file", r->data_file);
10648         }
10649         ndr->depth--;
10650         ndr_print_ptr(ndr, "config_file", r->config_file);
10651         ndr->depth++;
10652         if (r->config_file) {
10653                 ndr_print_string(ndr, "config_file", r->config_file);
10654         }
10655         ndr->depth--;
10656         ndr_print_ptr(ndr, "help_file", r->help_file);
10657         ndr->depth++;
10658         if (r->help_file) {
10659                 ndr_print_string(ndr, "help_file", r->help_file);
10660         }
10661         ndr->depth--;
10662         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10663         ndr->depth++;
10664         if (r->dependent_files) {
10665                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10666         }
10667         ndr->depth--;
10668         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10669         ndr->depth++;
10670         if (r->monitor_name) {
10671                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10672         }
10673         ndr->depth--;
10674         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10675         ndr->depth++;
10676         if (r->default_datatype) {
10677                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10678         }
10679         ndr->depth--;
10680         ndr->depth--;
10681 }
10682
10683 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10684 {
10685         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10686 }
10687
10688 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10689 {
10690         if (ndr_flags & NDR_SCALARS) {
10691                 NDR_CHECK(ndr_push_align(ndr, 4));
10692                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10693                 {
10694                         uint32_t _flags_save_string = ndr->flags;
10695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10696                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10697                         ndr->flags = _flags_save_string;
10698                 }
10699                 {
10700                         uint32_t _flags_save_string = ndr->flags;
10701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10702                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10703                         ndr->flags = _flags_save_string;
10704                 }
10705                 {
10706                         uint32_t _flags_save_string = ndr->flags;
10707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10708                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10709                         ndr->flags = _flags_save_string;
10710                 }
10711                 {
10712                         uint32_t _flags_save_string = ndr->flags;
10713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10714                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10715                         ndr->flags = _flags_save_string;
10716                 }
10717                 {
10718                         uint32_t _flags_save_string = ndr->flags;
10719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10720                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10721                         ndr->flags = _flags_save_string;
10722                 }
10723                 {
10724                         uint32_t _flags_save_string = ndr->flags;
10725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10726                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10727                         ndr->flags = _flags_save_string;
10728                 }
10729                 {
10730                         uint32_t _flags_save_string_array = ndr->flags;
10731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10732                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10733                         ndr->flags = _flags_save_string_array;
10734                 }
10735                 {
10736                         uint32_t _flags_save_string = ndr->flags;
10737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10738                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10739                         ndr->flags = _flags_save_string;
10740                 }
10741                 {
10742                         uint32_t _flags_save_string = ndr->flags;
10743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10745                         ndr->flags = _flags_save_string;
10746                 }
10747                 {
10748                         uint32_t _flags_save_string_array = ndr->flags;
10749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10751                         ndr->flags = _flags_save_string_array;
10752                 }
10753         }
10754         if (ndr_flags & NDR_BUFFERS) {
10755                 {
10756                         uint32_t _flags_save_string = ndr->flags;
10757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10758                         if (r->driver_name) {
10759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10760                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10761                         }
10762                         ndr->flags = _flags_save_string;
10763                 }
10764                 {
10765                         uint32_t _flags_save_string = ndr->flags;
10766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10767                         if (r->architecture) {
10768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10770                         }
10771                         ndr->flags = _flags_save_string;
10772                 }
10773                 {
10774                         uint32_t _flags_save_string = ndr->flags;
10775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10776                         if (r->driver_path) {
10777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10779                         }
10780                         ndr->flags = _flags_save_string;
10781                 }
10782                 {
10783                         uint32_t _flags_save_string = ndr->flags;
10784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10785                         if (r->data_file) {
10786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10788                         }
10789                         ndr->flags = _flags_save_string;
10790                 }
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         if (r->config_file) {
10795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10797                         }
10798                         ndr->flags = _flags_save_string;
10799                 }
10800                 {
10801                         uint32_t _flags_save_string = ndr->flags;
10802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10803                         if (r->help_file) {
10804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10806                         }
10807                         ndr->flags = _flags_save_string;
10808                 }
10809                 {
10810                         uint32_t _flags_save_string_array = ndr->flags;
10811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10812                         if (r->dependent_files) {
10813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10814                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10815                         }
10816                         ndr->flags = _flags_save_string_array;
10817                 }
10818                 {
10819                         uint32_t _flags_save_string = ndr->flags;
10820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10821                         if (r->monitor_name) {
10822                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10823                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10824                         }
10825                         ndr->flags = _flags_save_string;
10826                 }
10827                 {
10828                         uint32_t _flags_save_string = ndr->flags;
10829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10830                         if (r->default_datatype) {
10831                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10832                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10833                         }
10834                         ndr->flags = _flags_save_string;
10835                 }
10836                 {
10837                         uint32_t _flags_save_string_array = ndr->flags;
10838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10839                         if (r->previous_names) {
10840                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10841                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10842                         }
10843                         ndr->flags = _flags_save_string_array;
10844                 }
10845         }
10846         return NDR_ERR_SUCCESS;
10847 }
10848
10849 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10850 {
10851         uint32_t _ptr_driver_name;
10852         TALLOC_CTX *_mem_save_driver_name_0;
10853         uint32_t _ptr_architecture;
10854         TALLOC_CTX *_mem_save_architecture_0;
10855         uint32_t _ptr_driver_path;
10856         TALLOC_CTX *_mem_save_driver_path_0;
10857         uint32_t _ptr_data_file;
10858         TALLOC_CTX *_mem_save_data_file_0;
10859         uint32_t _ptr_config_file;
10860         TALLOC_CTX *_mem_save_config_file_0;
10861         uint32_t _ptr_help_file;
10862         TALLOC_CTX *_mem_save_help_file_0;
10863         uint32_t _ptr_dependent_files;
10864         TALLOC_CTX *_mem_save_dependent_files_0;
10865         uint32_t _ptr_monitor_name;
10866         TALLOC_CTX *_mem_save_monitor_name_0;
10867         uint32_t _ptr_default_datatype;
10868         TALLOC_CTX *_mem_save_default_datatype_0;
10869         uint32_t _ptr_previous_names;
10870         TALLOC_CTX *_mem_save_previous_names_0;
10871         if (ndr_flags & NDR_SCALARS) {
10872                 NDR_CHECK(ndr_pull_align(ndr, 4));
10873                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10874                 {
10875                         uint32_t _flags_save_string = ndr->flags;
10876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10877                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10878                         if (_ptr_driver_name) {
10879                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10880                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10881                         } else {
10882                                 r->driver_name = NULL;
10883                         }
10884                         ndr->flags = _flags_save_string;
10885                 }
10886                 {
10887                         uint32_t _flags_save_string = ndr->flags;
10888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10889                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10890                         if (_ptr_architecture) {
10891                                 NDR_PULL_ALLOC(ndr, r->architecture);
10892                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10893                         } else {
10894                                 r->architecture = NULL;
10895                         }
10896                         ndr->flags = _flags_save_string;
10897                 }
10898                 {
10899                         uint32_t _flags_save_string = ndr->flags;
10900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10901                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10902                         if (_ptr_driver_path) {
10903                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10905                         } else {
10906                                 r->driver_path = NULL;
10907                         }
10908                         ndr->flags = _flags_save_string;
10909                 }
10910                 {
10911                         uint32_t _flags_save_string = ndr->flags;
10912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10913                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10914                         if (_ptr_data_file) {
10915                                 NDR_PULL_ALLOC(ndr, r->data_file);
10916                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10917                         } else {
10918                                 r->data_file = NULL;
10919                         }
10920                         ndr->flags = _flags_save_string;
10921                 }
10922                 {
10923                         uint32_t _flags_save_string = ndr->flags;
10924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10925                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10926                         if (_ptr_config_file) {
10927                                 NDR_PULL_ALLOC(ndr, r->config_file);
10928                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10929                         } else {
10930                                 r->config_file = NULL;
10931                         }
10932                         ndr->flags = _flags_save_string;
10933                 }
10934                 {
10935                         uint32_t _flags_save_string = ndr->flags;
10936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10937                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10938                         if (_ptr_help_file) {
10939                                 NDR_PULL_ALLOC(ndr, r->help_file);
10940                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10941                         } else {
10942                                 r->help_file = NULL;
10943                         }
10944                         ndr->flags = _flags_save_string;
10945                 }
10946                 {
10947                         uint32_t _flags_save_string_array = ndr->flags;
10948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10949                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10950                         if (_ptr_dependent_files) {
10951                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10952                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10953                         } else {
10954                                 r->dependent_files = NULL;
10955                         }
10956                         ndr->flags = _flags_save_string_array;
10957                 }
10958                 {
10959                         uint32_t _flags_save_string = ndr->flags;
10960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10961                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10962                         if (_ptr_monitor_name) {
10963                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10964                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10965                         } else {
10966                                 r->monitor_name = NULL;
10967                         }
10968                         ndr->flags = _flags_save_string;
10969                 }
10970                 {
10971                         uint32_t _flags_save_string = ndr->flags;
10972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10973                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10974                         if (_ptr_default_datatype) {
10975                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10976                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10977                         } else {
10978                                 r->default_datatype = NULL;
10979                         }
10980                         ndr->flags = _flags_save_string;
10981                 }
10982                 {
10983                         uint32_t _flags_save_string_array = ndr->flags;
10984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10985                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10986                         if (_ptr_previous_names) {
10987                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10988                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10989                         } else {
10990                                 r->previous_names = NULL;
10991                         }
10992                         ndr->flags = _flags_save_string_array;
10993                 }
10994         }
10995         if (ndr_flags & NDR_BUFFERS) {
10996                 {
10997                         uint32_t _flags_save_string = ndr->flags;
10998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10999                         if (r->driver_name) {
11000                                 uint32_t _relative_save_offset;
11001                                 _relative_save_offset = ndr->offset;
11002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11003                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11004                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11007                                 ndr->offset = _relative_save_offset;
11008                         }
11009                         ndr->flags = _flags_save_string;
11010                 }
11011                 {
11012                         uint32_t _flags_save_string = ndr->flags;
11013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11014                         if (r->architecture) {
11015                                 uint32_t _relative_save_offset;
11016                                 _relative_save_offset = ndr->offset;
11017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11018                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11019                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11020                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11022                                 ndr->offset = _relative_save_offset;
11023                         }
11024                         ndr->flags = _flags_save_string;
11025                 }
11026                 {
11027                         uint32_t _flags_save_string = ndr->flags;
11028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11029                         if (r->driver_path) {
11030                                 uint32_t _relative_save_offset;
11031                                 _relative_save_offset = ndr->offset;
11032                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11033                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11034                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11035                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11037                                 ndr->offset = _relative_save_offset;
11038                         }
11039                         ndr->flags = _flags_save_string;
11040                 }
11041                 {
11042                         uint32_t _flags_save_string = ndr->flags;
11043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11044                         if (r->data_file) {
11045                                 uint32_t _relative_save_offset;
11046                                 _relative_save_offset = ndr->offset;
11047                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11048                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11049                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11050                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11051                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11052                                 ndr->offset = _relative_save_offset;
11053                         }
11054                         ndr->flags = _flags_save_string;
11055                 }
11056                 {
11057                         uint32_t _flags_save_string = ndr->flags;
11058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11059                         if (r->config_file) {
11060                                 uint32_t _relative_save_offset;
11061                                 _relative_save_offset = ndr->offset;
11062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11063                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11064                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11067                                 ndr->offset = _relative_save_offset;
11068                         }
11069                         ndr->flags = _flags_save_string;
11070                 }
11071                 {
11072                         uint32_t _flags_save_string = ndr->flags;
11073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11074                         if (r->help_file) {
11075                                 uint32_t _relative_save_offset;
11076                                 _relative_save_offset = ndr->offset;
11077                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11078                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11079                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11080                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11081                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11082                                 ndr->offset = _relative_save_offset;
11083                         }
11084                         ndr->flags = _flags_save_string;
11085                 }
11086                 {
11087                         uint32_t _flags_save_string_array = ndr->flags;
11088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11089                         if (r->dependent_files) {
11090                                 uint32_t _relative_save_offset;
11091                                 _relative_save_offset = ndr->offset;
11092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11093                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11094                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11095                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11096                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11097                                 ndr->offset = _relative_save_offset;
11098                         }
11099                         ndr->flags = _flags_save_string_array;
11100                 }
11101                 {
11102                         uint32_t _flags_save_string = ndr->flags;
11103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11104                         if (r->monitor_name) {
11105                                 uint32_t _relative_save_offset;
11106                                 _relative_save_offset = ndr->offset;
11107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11108                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11109                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11112                                 ndr->offset = _relative_save_offset;
11113                         }
11114                         ndr->flags = _flags_save_string;
11115                 }
11116                 {
11117                         uint32_t _flags_save_string = ndr->flags;
11118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11119                         if (r->default_datatype) {
11120                                 uint32_t _relative_save_offset;
11121                                 _relative_save_offset = ndr->offset;
11122                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11123                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11124                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11125                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11126                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11127                                 ndr->offset = _relative_save_offset;
11128                         }
11129                         ndr->flags = _flags_save_string;
11130                 }
11131                 {
11132                         uint32_t _flags_save_string_array = ndr->flags;
11133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11134                         if (r->previous_names) {
11135                                 uint32_t _relative_save_offset;
11136                                 _relative_save_offset = ndr->offset;
11137                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11138                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11139                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11140                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11141                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11142                                 ndr->offset = _relative_save_offset;
11143                         }
11144                         ndr->flags = _flags_save_string_array;
11145                 }
11146         }
11147         return NDR_ERR_SUCCESS;
11148 }
11149
11150 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11151 {
11152         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11153         ndr->depth++;
11154         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11155         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11156         ndr->depth++;
11157         if (r->driver_name) {
11158                 ndr_print_string(ndr, "driver_name", r->driver_name);
11159         }
11160         ndr->depth--;
11161         ndr_print_ptr(ndr, "architecture", r->architecture);
11162         ndr->depth++;
11163         if (r->architecture) {
11164                 ndr_print_string(ndr, "architecture", r->architecture);
11165         }
11166         ndr->depth--;
11167         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11168         ndr->depth++;
11169         if (r->driver_path) {
11170                 ndr_print_string(ndr, "driver_path", r->driver_path);
11171         }
11172         ndr->depth--;
11173         ndr_print_ptr(ndr, "data_file", r->data_file);
11174         ndr->depth++;
11175         if (r->data_file) {
11176                 ndr_print_string(ndr, "data_file", r->data_file);
11177         }
11178         ndr->depth--;
11179         ndr_print_ptr(ndr, "config_file", r->config_file);
11180         ndr->depth++;
11181         if (r->config_file) {
11182                 ndr_print_string(ndr, "config_file", r->config_file);
11183         }
11184         ndr->depth--;
11185         ndr_print_ptr(ndr, "help_file", r->help_file);
11186         ndr->depth++;
11187         if (r->help_file) {
11188                 ndr_print_string(ndr, "help_file", r->help_file);
11189         }
11190         ndr->depth--;
11191         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11192         ndr->depth++;
11193         if (r->dependent_files) {
11194                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11195         }
11196         ndr->depth--;
11197         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11198         ndr->depth++;
11199         if (r->monitor_name) {
11200                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11201         }
11202         ndr->depth--;
11203         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11204         ndr->depth++;
11205         if (r->default_datatype) {
11206                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11207         }
11208         ndr->depth--;
11209         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11210         ndr->depth++;
11211         if (r->previous_names) {
11212                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11213         }
11214         ndr->depth--;
11215         ndr->depth--;
11216 }
11217
11218 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11219 {
11220         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11221 }
11222
11223 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11224 {
11225         if (ndr_flags & NDR_SCALARS) {
11226                 NDR_CHECK(ndr_push_align(ndr, 4));
11227                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11228                 {
11229                         uint32_t _flags_save_string = ndr->flags;
11230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11231                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11232                         ndr->flags = _flags_save_string;
11233                 }
11234                 {
11235                         uint32_t _flags_save_string = ndr->flags;
11236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11237                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11238                         ndr->flags = _flags_save_string;
11239                 }
11240                 {
11241                         uint32_t _flags_save_string = ndr->flags;
11242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11243                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11244                         ndr->flags = _flags_save_string;
11245                 }
11246                 {
11247                         uint32_t _flags_save_string = ndr->flags;
11248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11249                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11250                         ndr->flags = _flags_save_string;
11251                 }
11252                 {
11253                         uint32_t _flags_save_string = ndr->flags;
11254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11255                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11256                         ndr->flags = _flags_save_string;
11257                 }
11258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
11259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11261         }
11262         if (ndr_flags & NDR_BUFFERS) {
11263                 {
11264                         uint32_t _flags_save_string = ndr->flags;
11265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11266                         if (r->driver_name) {
11267                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11268                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11269                         }
11270                         ndr->flags = _flags_save_string;
11271                 }
11272                 {
11273                         uint32_t _flags_save_string = ndr->flags;
11274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11275                         if (r->architecture) {
11276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11278                         }
11279                         ndr->flags = _flags_save_string;
11280                 }
11281                 {
11282                         uint32_t _flags_save_string = ndr->flags;
11283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11284                         if (r->driver_path) {
11285                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11286                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11287                         }
11288                         ndr->flags = _flags_save_string;
11289                 }
11290                 {
11291                         uint32_t _flags_save_string = ndr->flags;
11292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11293                         if (r->data_file) {
11294                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11295                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11296                         }
11297                         ndr->flags = _flags_save_string;
11298                 }
11299                 {
11300                         uint32_t _flags_save_string = ndr->flags;
11301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11302                         if (r->config_file) {
11303                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11304                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11305                         }
11306                         ndr->flags = _flags_save_string;
11307                 }
11308         }
11309         return NDR_ERR_SUCCESS;
11310 }
11311
11312 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11313 {
11314         uint32_t _ptr_driver_name;
11315         TALLOC_CTX *_mem_save_driver_name_0;
11316         uint32_t _ptr_architecture;
11317         TALLOC_CTX *_mem_save_architecture_0;
11318         uint32_t _ptr_driver_path;
11319         TALLOC_CTX *_mem_save_driver_path_0;
11320         uint32_t _ptr_data_file;
11321         TALLOC_CTX *_mem_save_data_file_0;
11322         uint32_t _ptr_config_file;
11323         TALLOC_CTX *_mem_save_config_file_0;
11324         if (ndr_flags & NDR_SCALARS) {
11325                 NDR_CHECK(ndr_pull_align(ndr, 4));
11326                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11327                 {
11328                         uint32_t _flags_save_string = ndr->flags;
11329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11330                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11331                         if (_ptr_driver_name) {
11332                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11333                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11334                         } else {
11335                                 r->driver_name = NULL;
11336                         }
11337                         ndr->flags = _flags_save_string;
11338                 }
11339                 {
11340                         uint32_t _flags_save_string = ndr->flags;
11341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11343                         if (_ptr_architecture) {
11344                                 NDR_PULL_ALLOC(ndr, r->architecture);
11345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11346                         } else {
11347                                 r->architecture = NULL;
11348                         }
11349                         ndr->flags = _flags_save_string;
11350                 }
11351                 {
11352                         uint32_t _flags_save_string = ndr->flags;
11353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11355                         if (_ptr_driver_path) {
11356                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11358                         } else {
11359                                 r->driver_path = NULL;
11360                         }
11361                         ndr->flags = _flags_save_string;
11362                 }
11363                 {
11364                         uint32_t _flags_save_string = ndr->flags;
11365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11366                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11367                         if (_ptr_data_file) {
11368                                 NDR_PULL_ALLOC(ndr, r->data_file);
11369                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11370                         } else {
11371                                 r->data_file = NULL;
11372                         }
11373                         ndr->flags = _flags_save_string;
11374                 }
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_config_file));
11379                         if (_ptr_config_file) {
11380                                 NDR_PULL_ALLOC(ndr, r->config_file);
11381                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11382                         } else {
11383                                 r->config_file = NULL;
11384                         }
11385                         ndr->flags = _flags_save_string;
11386                 }
11387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
11388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11390         }
11391         if (ndr_flags & NDR_BUFFERS) {
11392                 {
11393                         uint32_t _flags_save_string = ndr->flags;
11394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11395                         if (r->driver_name) {
11396                                 uint32_t _relative_save_offset;
11397                                 _relative_save_offset = ndr->offset;
11398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11399                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11400                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11403                                 ndr->offset = _relative_save_offset;
11404                         }
11405                         ndr->flags = _flags_save_string;
11406                 }
11407                 {
11408                         uint32_t _flags_save_string = ndr->flags;
11409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11410                         if (r->architecture) {
11411                                 uint32_t _relative_save_offset;
11412                                 _relative_save_offset = ndr->offset;
11413                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11414                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11415                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11416                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11417                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11418                                 ndr->offset = _relative_save_offset;
11419                         }
11420                         ndr->flags = _flags_save_string;
11421                 }
11422                 {
11423                         uint32_t _flags_save_string = ndr->flags;
11424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11425                         if (r->driver_path) {
11426                                 uint32_t _relative_save_offset;
11427                                 _relative_save_offset = ndr->offset;
11428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11429                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11430                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11431                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11433                                 ndr->offset = _relative_save_offset;
11434                         }
11435                         ndr->flags = _flags_save_string;
11436                 }
11437                 {
11438                         uint32_t _flags_save_string = ndr->flags;
11439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11440                         if (r->data_file) {
11441                                 uint32_t _relative_save_offset;
11442                                 _relative_save_offset = ndr->offset;
11443                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11444                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11445                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11446                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11447                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11448                                 ndr->offset = _relative_save_offset;
11449                         }
11450                         ndr->flags = _flags_save_string;
11451                 }
11452                 {
11453                         uint32_t _flags_save_string = ndr->flags;
11454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11455                         if (r->config_file) {
11456                                 uint32_t _relative_save_offset;
11457                                 _relative_save_offset = ndr->offset;
11458                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11459                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11460                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11461                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11462                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11463                                 ndr->offset = _relative_save_offset;
11464                         }
11465                         ndr->flags = _flags_save_string;
11466                 }
11467         }
11468         return NDR_ERR_SUCCESS;
11469 }
11470
11471 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11472 {
11473         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11474         ndr->depth++;
11475         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11476         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11477         ndr->depth++;
11478         if (r->driver_name) {
11479                 ndr_print_string(ndr, "driver_name", r->driver_name);
11480         }
11481         ndr->depth--;
11482         ndr_print_ptr(ndr, "architecture", r->architecture);
11483         ndr->depth++;
11484         if (r->architecture) {
11485                 ndr_print_string(ndr, "architecture", r->architecture);
11486         }
11487         ndr->depth--;
11488         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11489         ndr->depth++;
11490         if (r->driver_path) {
11491                 ndr_print_string(ndr, "driver_path", r->driver_path);
11492         }
11493         ndr->depth--;
11494         ndr_print_ptr(ndr, "data_file", r->data_file);
11495         ndr->depth++;
11496         if (r->data_file) {
11497                 ndr_print_string(ndr, "data_file", r->data_file);
11498         }
11499         ndr->depth--;
11500         ndr_print_ptr(ndr, "config_file", r->config_file);
11501         ndr->depth++;
11502         if (r->config_file) {
11503                 ndr_print_string(ndr, "config_file", r->config_file);
11504         }
11505         ndr->depth--;
11506         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
11507         ndr_print_uint32(ndr, "config_version", r->config_version);
11508         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11509         ndr->depth--;
11510 }
11511
11512 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11513 {
11514         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11515 }
11516
11517 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11518 {
11519         if (ndr_flags & NDR_SCALARS) {
11520                 NDR_CHECK(ndr_push_align(ndr, 8));
11521                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11522                 {
11523                         uint32_t _flags_save_string = ndr->flags;
11524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11526                         ndr->flags = _flags_save_string;
11527                 }
11528                 {
11529                         uint32_t _flags_save_string = ndr->flags;
11530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11538                         ndr->flags = _flags_save_string;
11539                 }
11540                 {
11541                         uint32_t _flags_save_string = ndr->flags;
11542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11544                         ndr->flags = _flags_save_string;
11545                 }
11546                 {
11547                         uint32_t _flags_save_string = ndr->flags;
11548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11550                         ndr->flags = _flags_save_string;
11551                 }
11552                 {
11553                         uint32_t _flags_save_string = ndr->flags;
11554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11556                         ndr->flags = _flags_save_string;
11557                 }
11558                 {
11559                         uint32_t _flags_save_string_array = ndr->flags;
11560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11562                         ndr->flags = _flags_save_string_array;
11563                 }
11564                 {
11565                         uint32_t _flags_save_string = ndr->flags;
11566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11567                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11568                         ndr->flags = _flags_save_string;
11569                 }
11570                 {
11571                         uint32_t _flags_save_string = ndr->flags;
11572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11573                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11574                         ndr->flags = _flags_save_string;
11575                 }
11576                 {
11577                         uint32_t _flags_save_string_array = ndr->flags;
11578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11580                         ndr->flags = _flags_save_string_array;
11581                 }
11582                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11583                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11584                 {
11585                         uint32_t _flags_save_string = ndr->flags;
11586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11588                         ndr->flags = _flags_save_string;
11589                 }
11590                 {
11591                         uint32_t _flags_save_string = ndr->flags;
11592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11593                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11594                         ndr->flags = _flags_save_string;
11595                 }
11596                 {
11597                         uint32_t _flags_save_string = ndr->flags;
11598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11600                         ndr->flags = _flags_save_string;
11601                 }
11602                 {
11603                         uint32_t _flags_save_string = ndr->flags;
11604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11606                         ndr->flags = _flags_save_string;
11607                 }
11608         }
11609         if (ndr_flags & NDR_BUFFERS) {
11610                 {
11611                         uint32_t _flags_save_string = ndr->flags;
11612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11613                         if (r->driver_name) {
11614                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11616                         }
11617                         ndr->flags = _flags_save_string;
11618                 }
11619                 {
11620                         uint32_t _flags_save_string = ndr->flags;
11621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11622                         if (r->architecture) {
11623                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11625                         }
11626                         ndr->flags = _flags_save_string;
11627                 }
11628                 {
11629                         uint32_t _flags_save_string = ndr->flags;
11630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11631                         if (r->driver_path) {
11632                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11633                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11634                         }
11635                         ndr->flags = _flags_save_string;
11636                 }
11637                 {
11638                         uint32_t _flags_save_string = ndr->flags;
11639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11640                         if (r->data_file) {
11641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11643                         }
11644                         ndr->flags = _flags_save_string;
11645                 }
11646                 {
11647                         uint32_t _flags_save_string = ndr->flags;
11648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11649                         if (r->config_file) {
11650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11652                         }
11653                         ndr->flags = _flags_save_string;
11654                 }
11655                 {
11656                         uint32_t _flags_save_string = ndr->flags;
11657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11658                         if (r->help_file) {
11659                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11660                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11661                         }
11662                         ndr->flags = _flags_save_string;
11663                 }
11664                 {
11665                         uint32_t _flags_save_string_array = ndr->flags;
11666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11667                         if (r->dependent_files) {
11668                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11669                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11670                         }
11671                         ndr->flags = _flags_save_string_array;
11672                 }
11673                 {
11674                         uint32_t _flags_save_string = ndr->flags;
11675                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11676                         if (r->monitor_name) {
11677                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11678                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11679                         }
11680                         ndr->flags = _flags_save_string;
11681                 }
11682                 {
11683                         uint32_t _flags_save_string = ndr->flags;
11684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11685                         if (r->default_datatype) {
11686                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11687                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11688                         }
11689                         ndr->flags = _flags_save_string;
11690                 }
11691                 {
11692                         uint32_t _flags_save_string_array = ndr->flags;
11693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11694                         if (r->previous_names) {
11695                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11696                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11697                         }
11698                         ndr->flags = _flags_save_string_array;
11699                 }
11700                 {
11701                         uint32_t _flags_save_string = ndr->flags;
11702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11703                         if (r->manufacturer_name) {
11704                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11705                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11706                         }
11707                         ndr->flags = _flags_save_string;
11708                 }
11709                 {
11710                         uint32_t _flags_save_string = ndr->flags;
11711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11712                         if (r->manufacturer_url) {
11713                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11714                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11715                         }
11716                         ndr->flags = _flags_save_string;
11717                 }
11718                 {
11719                         uint32_t _flags_save_string = ndr->flags;
11720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11721                         if (r->hardware_id) {
11722                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11723                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11724                         }
11725                         ndr->flags = _flags_save_string;
11726                 }
11727                 {
11728                         uint32_t _flags_save_string = ndr->flags;
11729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11730                         if (r->provider) {
11731                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11732                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11733                         }
11734                         ndr->flags = _flags_save_string;
11735                 }
11736         }
11737         return NDR_ERR_SUCCESS;
11738 }
11739
11740 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11741 {
11742         uint32_t _ptr_driver_name;
11743         TALLOC_CTX *_mem_save_driver_name_0;
11744         uint32_t _ptr_architecture;
11745         TALLOC_CTX *_mem_save_architecture_0;
11746         uint32_t _ptr_driver_path;
11747         TALLOC_CTX *_mem_save_driver_path_0;
11748         uint32_t _ptr_data_file;
11749         TALLOC_CTX *_mem_save_data_file_0;
11750         uint32_t _ptr_config_file;
11751         TALLOC_CTX *_mem_save_config_file_0;
11752         uint32_t _ptr_help_file;
11753         TALLOC_CTX *_mem_save_help_file_0;
11754         uint32_t _ptr_dependent_files;
11755         TALLOC_CTX *_mem_save_dependent_files_0;
11756         uint32_t _ptr_monitor_name;
11757         TALLOC_CTX *_mem_save_monitor_name_0;
11758         uint32_t _ptr_default_datatype;
11759         TALLOC_CTX *_mem_save_default_datatype_0;
11760         uint32_t _ptr_previous_names;
11761         TALLOC_CTX *_mem_save_previous_names_0;
11762         uint32_t _ptr_manufacturer_name;
11763         TALLOC_CTX *_mem_save_manufacturer_name_0;
11764         uint32_t _ptr_manufacturer_url;
11765         TALLOC_CTX *_mem_save_manufacturer_url_0;
11766         uint32_t _ptr_hardware_id;
11767         TALLOC_CTX *_mem_save_hardware_id_0;
11768         uint32_t _ptr_provider;
11769         TALLOC_CTX *_mem_save_provider_0;
11770         if (ndr_flags & NDR_SCALARS) {
11771                 NDR_CHECK(ndr_pull_align(ndr, 8));
11772                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11773                 {
11774                         uint32_t _flags_save_string = ndr->flags;
11775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11777                         if (_ptr_driver_name) {
11778                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11780                         } else {
11781                                 r->driver_name = NULL;
11782                         }
11783                         ndr->flags = _flags_save_string;
11784                 }
11785                 {
11786                         uint32_t _flags_save_string = ndr->flags;
11787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11788                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11789                         if (_ptr_architecture) {
11790                                 NDR_PULL_ALLOC(ndr, r->architecture);
11791                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11792                         } else {
11793                                 r->architecture = NULL;
11794                         }
11795                         ndr->flags = _flags_save_string;
11796                 }
11797                 {
11798                         uint32_t _flags_save_string = ndr->flags;
11799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11800                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11801                         if (_ptr_driver_path) {
11802                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11803                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11804                         } else {
11805                                 r->driver_path = NULL;
11806                         }
11807                         ndr->flags = _flags_save_string;
11808                 }
11809                 {
11810                         uint32_t _flags_save_string = ndr->flags;
11811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11812                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11813                         if (_ptr_data_file) {
11814                                 NDR_PULL_ALLOC(ndr, r->data_file);
11815                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11816                         } else {
11817                                 r->data_file = NULL;
11818                         }
11819                         ndr->flags = _flags_save_string;
11820                 }
11821                 {
11822                         uint32_t _flags_save_string = ndr->flags;
11823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11824                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11825                         if (_ptr_config_file) {
11826                                 NDR_PULL_ALLOC(ndr, r->config_file);
11827                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11828                         } else {
11829                                 r->config_file = NULL;
11830                         }
11831                         ndr->flags = _flags_save_string;
11832                 }
11833                 {
11834                         uint32_t _flags_save_string = ndr->flags;
11835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11837                         if (_ptr_help_file) {
11838                                 NDR_PULL_ALLOC(ndr, r->help_file);
11839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11840                         } else {
11841                                 r->help_file = NULL;
11842                         }
11843                         ndr->flags = _flags_save_string;
11844                 }
11845                 {
11846                         uint32_t _flags_save_string_array = ndr->flags;
11847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11849                         if (_ptr_dependent_files) {
11850                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11852                         } else {
11853                                 r->dependent_files = NULL;
11854                         }
11855                         ndr->flags = _flags_save_string_array;
11856                 }
11857                 {
11858                         uint32_t _flags_save_string = ndr->flags;
11859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11861                         if (_ptr_monitor_name) {
11862                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11864                         } else {
11865                                 r->monitor_name = NULL;
11866                         }
11867                         ndr->flags = _flags_save_string;
11868                 }
11869                 {
11870                         uint32_t _flags_save_string = ndr->flags;
11871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11872                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11873                         if (_ptr_default_datatype) {
11874                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11875                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11876                         } else {
11877                                 r->default_datatype = NULL;
11878                         }
11879                         ndr->flags = _flags_save_string;
11880                 }
11881                 {
11882                         uint32_t _flags_save_string_array = ndr->flags;
11883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11884                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11885                         if (_ptr_previous_names) {
11886                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11887                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11888                         } else {
11889                                 r->previous_names = NULL;
11890                         }
11891                         ndr->flags = _flags_save_string_array;
11892                 }
11893                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11894                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11895                 {
11896                         uint32_t _flags_save_string = ndr->flags;
11897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11898                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11899                         if (_ptr_manufacturer_name) {
11900                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11901                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11902                         } else {
11903                                 r->manufacturer_name = NULL;
11904                         }
11905                         ndr->flags = _flags_save_string;
11906                 }
11907                 {
11908                         uint32_t _flags_save_string = ndr->flags;
11909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11911                         if (_ptr_manufacturer_url) {
11912                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11914                         } else {
11915                                 r->manufacturer_url = NULL;
11916                         }
11917                         ndr->flags = _flags_save_string;
11918                 }
11919                 {
11920                         uint32_t _flags_save_string = ndr->flags;
11921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11922                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11923                         if (_ptr_hardware_id) {
11924                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11925                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11926                         } else {
11927                                 r->hardware_id = NULL;
11928                         }
11929                         ndr->flags = _flags_save_string;
11930                 }
11931                 {
11932                         uint32_t _flags_save_string = ndr->flags;
11933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11934                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11935                         if (_ptr_provider) {
11936                                 NDR_PULL_ALLOC(ndr, r->provider);
11937                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11938                         } else {
11939                                 r->provider = NULL;
11940                         }
11941                         ndr->flags = _flags_save_string;
11942                 }
11943         }
11944         if (ndr_flags & NDR_BUFFERS) {
11945                 {
11946                         uint32_t _flags_save_string = ndr->flags;
11947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11948                         if (r->driver_name) {
11949                                 uint32_t _relative_save_offset;
11950                                 _relative_save_offset = ndr->offset;
11951                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11952                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11953                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11954                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11955                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11956                                 ndr->offset = _relative_save_offset;
11957                         }
11958                         ndr->flags = _flags_save_string;
11959                 }
11960                 {
11961                         uint32_t _flags_save_string = ndr->flags;
11962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11963                         if (r->architecture) {
11964                                 uint32_t _relative_save_offset;
11965                                 _relative_save_offset = ndr->offset;
11966                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11967                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11968                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11969                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11970                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11971                                 ndr->offset = _relative_save_offset;
11972                         }
11973                         ndr->flags = _flags_save_string;
11974                 }
11975                 {
11976                         uint32_t _flags_save_string = ndr->flags;
11977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11978                         if (r->driver_path) {
11979                                 uint32_t _relative_save_offset;
11980                                 _relative_save_offset = ndr->offset;
11981                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11982                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11983                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11984                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11985                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11986                                 ndr->offset = _relative_save_offset;
11987                         }
11988                         ndr->flags = _flags_save_string;
11989                 }
11990                 {
11991                         uint32_t _flags_save_string = ndr->flags;
11992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11993                         if (r->data_file) {
11994                                 uint32_t _relative_save_offset;
11995                                 _relative_save_offset = ndr->offset;
11996                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11997                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11998                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11999                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12000                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12001                                 ndr->offset = _relative_save_offset;
12002                         }
12003                         ndr->flags = _flags_save_string;
12004                 }
12005                 {
12006                         uint32_t _flags_save_string = ndr->flags;
12007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12008                         if (r->config_file) {
12009                                 uint32_t _relative_save_offset;
12010                                 _relative_save_offset = ndr->offset;
12011                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12012                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12013                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12014                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12015                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12016                                 ndr->offset = _relative_save_offset;
12017                         }
12018                         ndr->flags = _flags_save_string;
12019                 }
12020                 {
12021                         uint32_t _flags_save_string = ndr->flags;
12022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12023                         if (r->help_file) {
12024                                 uint32_t _relative_save_offset;
12025                                 _relative_save_offset = ndr->offset;
12026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12027                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12028                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12031                                 ndr->offset = _relative_save_offset;
12032                         }
12033                         ndr->flags = _flags_save_string;
12034                 }
12035                 {
12036                         uint32_t _flags_save_string_array = ndr->flags;
12037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12038                         if (r->dependent_files) {
12039                                 uint32_t _relative_save_offset;
12040                                 _relative_save_offset = ndr->offset;
12041                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12042                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12043                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12044                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12045                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12046                                 ndr->offset = _relative_save_offset;
12047                         }
12048                         ndr->flags = _flags_save_string_array;
12049                 }
12050                 {
12051                         uint32_t _flags_save_string = ndr->flags;
12052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12053                         if (r->monitor_name) {
12054                                 uint32_t _relative_save_offset;
12055                                 _relative_save_offset = ndr->offset;
12056                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12057                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12058                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12059                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12060                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12061                                 ndr->offset = _relative_save_offset;
12062                         }
12063                         ndr->flags = _flags_save_string;
12064                 }
12065                 {
12066                         uint32_t _flags_save_string = ndr->flags;
12067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12068                         if (r->default_datatype) {
12069                                 uint32_t _relative_save_offset;
12070                                 _relative_save_offset = ndr->offset;
12071                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12072                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12073                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12074                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12075                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12076                                 ndr->offset = _relative_save_offset;
12077                         }
12078                         ndr->flags = _flags_save_string;
12079                 }
12080                 {
12081                         uint32_t _flags_save_string_array = ndr->flags;
12082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12083                         if (r->previous_names) {
12084                                 uint32_t _relative_save_offset;
12085                                 _relative_save_offset = ndr->offset;
12086                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12087                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12088                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12089                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12090                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12091                                 ndr->offset = _relative_save_offset;
12092                         }
12093                         ndr->flags = _flags_save_string_array;
12094                 }
12095                 {
12096                         uint32_t _flags_save_string = ndr->flags;
12097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12098                         if (r->manufacturer_name) {
12099                                 uint32_t _relative_save_offset;
12100                                 _relative_save_offset = ndr->offset;
12101                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12102                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12103                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12104                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12105                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12106                                 ndr->offset = _relative_save_offset;
12107                         }
12108                         ndr->flags = _flags_save_string;
12109                 }
12110                 {
12111                         uint32_t _flags_save_string = ndr->flags;
12112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12113                         if (r->manufacturer_url) {
12114                                 uint32_t _relative_save_offset;
12115                                 _relative_save_offset = ndr->offset;
12116                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12117                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12118                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12119                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12120                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12121                                 ndr->offset = _relative_save_offset;
12122                         }
12123                         ndr->flags = _flags_save_string;
12124                 }
12125                 {
12126                         uint32_t _flags_save_string = ndr->flags;
12127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12128                         if (r->hardware_id) {
12129                                 uint32_t _relative_save_offset;
12130                                 _relative_save_offset = ndr->offset;
12131                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12132                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12133                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12134                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12135                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12136                                 ndr->offset = _relative_save_offset;
12137                         }
12138                         ndr->flags = _flags_save_string;
12139                 }
12140                 {
12141                         uint32_t _flags_save_string = ndr->flags;
12142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12143                         if (r->provider) {
12144                                 uint32_t _relative_save_offset;
12145                                 _relative_save_offset = ndr->offset;
12146                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12147                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12148                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12149                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12150                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12151                                 ndr->offset = _relative_save_offset;
12152                         }
12153                         ndr->flags = _flags_save_string;
12154                 }
12155         }
12156         return NDR_ERR_SUCCESS;
12157 }
12158
12159 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12160 {
12161         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12162         ndr->depth++;
12163         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12164         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12165         ndr->depth++;
12166         if (r->driver_name) {
12167                 ndr_print_string(ndr, "driver_name", r->driver_name);
12168         }
12169         ndr->depth--;
12170         ndr_print_ptr(ndr, "architecture", r->architecture);
12171         ndr->depth++;
12172         if (r->architecture) {
12173                 ndr_print_string(ndr, "architecture", r->architecture);
12174         }
12175         ndr->depth--;
12176         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12177         ndr->depth++;
12178         if (r->driver_path) {
12179                 ndr_print_string(ndr, "driver_path", r->driver_path);
12180         }
12181         ndr->depth--;
12182         ndr_print_ptr(ndr, "data_file", r->data_file);
12183         ndr->depth++;
12184         if (r->data_file) {
12185                 ndr_print_string(ndr, "data_file", r->data_file);
12186         }
12187         ndr->depth--;
12188         ndr_print_ptr(ndr, "config_file", r->config_file);
12189         ndr->depth++;
12190         if (r->config_file) {
12191                 ndr_print_string(ndr, "config_file", r->config_file);
12192         }
12193         ndr->depth--;
12194         ndr_print_ptr(ndr, "help_file", r->help_file);
12195         ndr->depth++;
12196         if (r->help_file) {
12197                 ndr_print_string(ndr, "help_file", r->help_file);
12198         }
12199         ndr->depth--;
12200         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12201         ndr->depth++;
12202         if (r->dependent_files) {
12203                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12204         }
12205         ndr->depth--;
12206         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12207         ndr->depth++;
12208         if (r->monitor_name) {
12209                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12210         }
12211         ndr->depth--;
12212         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12213         ndr->depth++;
12214         if (r->default_datatype) {
12215                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12216         }
12217         ndr->depth--;
12218         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12219         ndr->depth++;
12220         if (r->previous_names) {
12221                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12222         }
12223         ndr->depth--;
12224         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12225         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12226         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12227         ndr->depth++;
12228         if (r->manufacturer_name) {
12229                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12230         }
12231         ndr->depth--;
12232         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12233         ndr->depth++;
12234         if (r->manufacturer_url) {
12235                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12236         }
12237         ndr->depth--;
12238         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12239         ndr->depth++;
12240         if (r->hardware_id) {
12241                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12242         }
12243         ndr->depth--;
12244         ndr_print_ptr(ndr, "provider", r->provider);
12245         ndr->depth++;
12246         if (r->provider) {
12247                 ndr_print_string(ndr, "provider", r->provider);
12248         }
12249         ndr->depth--;
12250         ndr->depth--;
12251 }
12252
12253 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12254 {
12255         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12256 }
12257
12258 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12259 {
12260         if (ndr_flags & NDR_SCALARS) {
12261                 NDR_CHECK(ndr_push_align(ndr, 8));
12262                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12263                 {
12264                         uint32_t _flags_save_string = ndr->flags;
12265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12266                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12267                         ndr->flags = _flags_save_string;
12268                 }
12269                 {
12270                         uint32_t _flags_save_string = ndr->flags;
12271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12272                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12273                         ndr->flags = _flags_save_string;
12274                 }
12275                 {
12276                         uint32_t _flags_save_string = ndr->flags;
12277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12278                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12279                         ndr->flags = _flags_save_string;
12280                 }
12281                 {
12282                         uint32_t _flags_save_string = ndr->flags;
12283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12284                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12285                         ndr->flags = _flags_save_string;
12286                 }
12287                 {
12288                         uint32_t _flags_save_string = ndr->flags;
12289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12290                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12291                         ndr->flags = _flags_save_string;
12292                 }
12293                 {
12294                         uint32_t _flags_save_string = ndr->flags;
12295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12297                         ndr->flags = _flags_save_string;
12298                 }
12299                 {
12300                         uint32_t _flags_save_string = ndr->flags;
12301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12303                         ndr->flags = _flags_save_string;
12304                 }
12305                 {
12306                         uint32_t _flags_save_string = ndr->flags;
12307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12308                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12309                         ndr->flags = _flags_save_string;
12310                 }
12311                 {
12312                         uint32_t _flags_save_string_array = ndr->flags;
12313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12315                         ndr->flags = _flags_save_string_array;
12316                 }
12317                 {
12318                         uint32_t _flags_save_string_array = ndr->flags;
12319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12321                         ndr->flags = _flags_save_string_array;
12322                 }
12323                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12324                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12325                 {
12326                         uint32_t _flags_save_string = ndr->flags;
12327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12328                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12329                         ndr->flags = _flags_save_string;
12330                 }
12331                 {
12332                         uint32_t _flags_save_string = ndr->flags;
12333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12334                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12335                         ndr->flags = _flags_save_string;
12336                 }
12337                 {
12338                         uint32_t _flags_save_string = ndr->flags;
12339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12340                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12341                         ndr->flags = _flags_save_string;
12342                 }
12343                 {
12344                         uint32_t _flags_save_string = ndr->flags;
12345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12346                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12347                         ndr->flags = _flags_save_string;
12348                 }
12349                 {
12350                         uint32_t _flags_save_string = ndr->flags;
12351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12352                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12353                         ndr->flags = _flags_save_string;
12354                 }
12355                 {
12356                         uint32_t _flags_save_string = ndr->flags;
12357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12358                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12359                         ndr->flags = _flags_save_string;
12360                 }
12361                 {
12362                         uint32_t _flags_save_string_array = ndr->flags;
12363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12364                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12365                         ndr->flags = _flags_save_string_array;
12366                 }
12367                 {
12368                         uint32_t _flags_save_string = ndr->flags;
12369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12370                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12371                         ndr->flags = _flags_save_string;
12372                 }
12373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12374                 {
12375                         uint32_t _flags_save_string_array = ndr->flags;
12376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12377                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12378                         ndr->flags = _flags_save_string_array;
12379                 }
12380                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12381                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12382         }
12383         if (ndr_flags & NDR_BUFFERS) {
12384                 {
12385                         uint32_t _flags_save_string = ndr->flags;
12386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12387                         if (r->driver_name) {
12388                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12389                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12390                         }
12391                         ndr->flags = _flags_save_string;
12392                 }
12393                 {
12394                         uint32_t _flags_save_string = ndr->flags;
12395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12396                         if (r->architecture) {
12397                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12398                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12399                         }
12400                         ndr->flags = _flags_save_string;
12401                 }
12402                 {
12403                         uint32_t _flags_save_string = ndr->flags;
12404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12405                         if (r->driver_path) {
12406                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12407                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12408                         }
12409                         ndr->flags = _flags_save_string;
12410                 }
12411                 {
12412                         uint32_t _flags_save_string = ndr->flags;
12413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12414                         if (r->data_file) {
12415                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12416                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
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                         if (r->config_file) {
12424                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12425                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12426                         }
12427                         ndr->flags = _flags_save_string;
12428                 }
12429                 {
12430                         uint32_t _flags_save_string = ndr->flags;
12431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12432                         if (r->help_file) {
12433                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12434                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12435                         }
12436                         ndr->flags = _flags_save_string;
12437                 }
12438                 {
12439                         uint32_t _flags_save_string = ndr->flags;
12440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12441                         if (r->monitor_name) {
12442                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12443                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12444                         }
12445                         ndr->flags = _flags_save_string;
12446                 }
12447                 {
12448                         uint32_t _flags_save_string = ndr->flags;
12449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12450                         if (r->default_datatype) {
12451                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12452                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12453                         }
12454                         ndr->flags = _flags_save_string;
12455                 }
12456                 {
12457                         uint32_t _flags_save_string_array = ndr->flags;
12458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12459                         if (r->dependent_files) {
12460                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12461                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12462                         }
12463                         ndr->flags = _flags_save_string_array;
12464                 }
12465                 {
12466                         uint32_t _flags_save_string_array = ndr->flags;
12467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12468                         if (r->previous_names) {
12469                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12470                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12471                         }
12472                         ndr->flags = _flags_save_string_array;
12473                 }
12474                 {
12475                         uint32_t _flags_save_string = ndr->flags;
12476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12477                         if (r->manufacturer_name) {
12478                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12479                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12480                         }
12481                         ndr->flags = _flags_save_string;
12482                 }
12483                 {
12484                         uint32_t _flags_save_string = ndr->flags;
12485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12486                         if (r->manufacturer_url) {
12487                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12488                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12489                         }
12490                         ndr->flags = _flags_save_string;
12491                 }
12492                 {
12493                         uint32_t _flags_save_string = ndr->flags;
12494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12495                         if (r->hardware_id) {
12496                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12497                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12498                         }
12499                         ndr->flags = _flags_save_string;
12500                 }
12501                 {
12502                         uint32_t _flags_save_string = ndr->flags;
12503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12504                         if (r->provider) {
12505                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12506                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12507                         }
12508                         ndr->flags = _flags_save_string;
12509                 }
12510                 {
12511                         uint32_t _flags_save_string = ndr->flags;
12512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12513                         if (r->print_processor) {
12514                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12515                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12516                         }
12517                         ndr->flags = _flags_save_string;
12518                 }
12519                 {
12520                         uint32_t _flags_save_string = ndr->flags;
12521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12522                         if (r->vendor_setup) {
12523                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12524                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12525                         }
12526                         ndr->flags = _flags_save_string;
12527                 }
12528                 {
12529                         uint32_t _flags_save_string_array = ndr->flags;
12530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12531                         if (r->color_profiles) {
12532                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12533                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12534                         }
12535                         ndr->flags = _flags_save_string_array;
12536                 }
12537                 {
12538                         uint32_t _flags_save_string = ndr->flags;
12539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12540                         if (r->inf_path) {
12541                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12542                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12543                         }
12544                         ndr->flags = _flags_save_string;
12545                 }
12546                 {
12547                         uint32_t _flags_save_string_array = ndr->flags;
12548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12549                         if (r->core_driver_dependencies) {
12550                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12551                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12552                         }
12553                         ndr->flags = _flags_save_string_array;
12554                 }
12555         }
12556         return NDR_ERR_SUCCESS;
12557 }
12558
12559 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12560 {
12561         uint32_t _ptr_driver_name;
12562         TALLOC_CTX *_mem_save_driver_name_0;
12563         uint32_t _ptr_architecture;
12564         TALLOC_CTX *_mem_save_architecture_0;
12565         uint32_t _ptr_driver_path;
12566         TALLOC_CTX *_mem_save_driver_path_0;
12567         uint32_t _ptr_data_file;
12568         TALLOC_CTX *_mem_save_data_file_0;
12569         uint32_t _ptr_config_file;
12570         TALLOC_CTX *_mem_save_config_file_0;
12571         uint32_t _ptr_help_file;
12572         TALLOC_CTX *_mem_save_help_file_0;
12573         uint32_t _ptr_monitor_name;
12574         TALLOC_CTX *_mem_save_monitor_name_0;
12575         uint32_t _ptr_default_datatype;
12576         TALLOC_CTX *_mem_save_default_datatype_0;
12577         uint32_t _ptr_dependent_files;
12578         TALLOC_CTX *_mem_save_dependent_files_0;
12579         uint32_t _ptr_previous_names;
12580         TALLOC_CTX *_mem_save_previous_names_0;
12581         uint32_t _ptr_manufacturer_name;
12582         TALLOC_CTX *_mem_save_manufacturer_name_0;
12583         uint32_t _ptr_manufacturer_url;
12584         TALLOC_CTX *_mem_save_manufacturer_url_0;
12585         uint32_t _ptr_hardware_id;
12586         TALLOC_CTX *_mem_save_hardware_id_0;
12587         uint32_t _ptr_provider;
12588         TALLOC_CTX *_mem_save_provider_0;
12589         uint32_t _ptr_print_processor;
12590         TALLOC_CTX *_mem_save_print_processor_0;
12591         uint32_t _ptr_vendor_setup;
12592         TALLOC_CTX *_mem_save_vendor_setup_0;
12593         uint32_t _ptr_color_profiles;
12594         TALLOC_CTX *_mem_save_color_profiles_0;
12595         uint32_t _ptr_inf_path;
12596         TALLOC_CTX *_mem_save_inf_path_0;
12597         uint32_t _ptr_core_driver_dependencies;
12598         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12599         if (ndr_flags & NDR_SCALARS) {
12600                 NDR_CHECK(ndr_pull_align(ndr, 8));
12601                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12602                 {
12603                         uint32_t _flags_save_string = ndr->flags;
12604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12605                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12606                         if (_ptr_driver_name) {
12607                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12608                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12609                         } else {
12610                                 r->driver_name = NULL;
12611                         }
12612                         ndr->flags = _flags_save_string;
12613                 }
12614                 {
12615                         uint32_t _flags_save_string = ndr->flags;
12616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12617                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12618                         if (_ptr_architecture) {
12619                                 NDR_PULL_ALLOC(ndr, r->architecture);
12620                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12621                         } else {
12622                                 r->architecture = NULL;
12623                         }
12624                         ndr->flags = _flags_save_string;
12625                 }
12626                 {
12627                         uint32_t _flags_save_string = ndr->flags;
12628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12629                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12630                         if (_ptr_driver_path) {
12631                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12632                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12633                         } else {
12634                                 r->driver_path = NULL;
12635                         }
12636                         ndr->flags = _flags_save_string;
12637                 }
12638                 {
12639                         uint32_t _flags_save_string = ndr->flags;
12640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12641                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12642                         if (_ptr_data_file) {
12643                                 NDR_PULL_ALLOC(ndr, r->data_file);
12644                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12645                         } else {
12646                                 r->data_file = NULL;
12647                         }
12648                         ndr->flags = _flags_save_string;
12649                 }
12650                 {
12651                         uint32_t _flags_save_string = ndr->flags;
12652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12653                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12654                         if (_ptr_config_file) {
12655                                 NDR_PULL_ALLOC(ndr, r->config_file);
12656                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12657                         } else {
12658                                 r->config_file = NULL;
12659                         }
12660                         ndr->flags = _flags_save_string;
12661                 }
12662                 {
12663                         uint32_t _flags_save_string = ndr->flags;
12664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12665                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12666                         if (_ptr_help_file) {
12667                                 NDR_PULL_ALLOC(ndr, r->help_file);
12668                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12669                         } else {
12670                                 r->help_file = NULL;
12671                         }
12672                         ndr->flags = _flags_save_string;
12673                 }
12674                 {
12675                         uint32_t _flags_save_string = ndr->flags;
12676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12677                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12678                         if (_ptr_monitor_name) {
12679                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12680                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12681                         } else {
12682                                 r->monitor_name = NULL;
12683                         }
12684                         ndr->flags = _flags_save_string;
12685                 }
12686                 {
12687                         uint32_t _flags_save_string = ndr->flags;
12688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12689                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12690                         if (_ptr_default_datatype) {
12691                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12692                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12693                         } else {
12694                                 r->default_datatype = NULL;
12695                         }
12696                         ndr->flags = _flags_save_string;
12697                 }
12698                 {
12699                         uint32_t _flags_save_string_array = ndr->flags;
12700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12701                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12702                         if (_ptr_dependent_files) {
12703                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12704                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12705                         } else {
12706                                 r->dependent_files = NULL;
12707                         }
12708                         ndr->flags = _flags_save_string_array;
12709                 }
12710                 {
12711                         uint32_t _flags_save_string_array = ndr->flags;
12712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12713                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12714                         if (_ptr_previous_names) {
12715                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12716                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12717                         } else {
12718                                 r->previous_names = NULL;
12719                         }
12720                         ndr->flags = _flags_save_string_array;
12721                 }
12722                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12723                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12724                 {
12725                         uint32_t _flags_save_string = ndr->flags;
12726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12728                         if (_ptr_manufacturer_name) {
12729                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12731                         } else {
12732                                 r->manufacturer_name = NULL;
12733                         }
12734                         ndr->flags = _flags_save_string;
12735                 }
12736                 {
12737                         uint32_t _flags_save_string = ndr->flags;
12738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12739                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12740                         if (_ptr_manufacturer_url) {
12741                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12742                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12743                         } else {
12744                                 r->manufacturer_url = NULL;
12745                         }
12746                         ndr->flags = _flags_save_string;
12747                 }
12748                 {
12749                         uint32_t _flags_save_string = ndr->flags;
12750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12752                         if (_ptr_hardware_id) {
12753                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12755                         } else {
12756                                 r->hardware_id = NULL;
12757                         }
12758                         ndr->flags = _flags_save_string;
12759                 }
12760                 {
12761                         uint32_t _flags_save_string = ndr->flags;
12762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12764                         if (_ptr_provider) {
12765                                 NDR_PULL_ALLOC(ndr, r->provider);
12766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12767                         } else {
12768                                 r->provider = NULL;
12769                         }
12770                         ndr->flags = _flags_save_string;
12771                 }
12772                 {
12773                         uint32_t _flags_save_string = ndr->flags;
12774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12776                         if (_ptr_print_processor) {
12777                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12779                         } else {
12780                                 r->print_processor = NULL;
12781                         }
12782                         ndr->flags = _flags_save_string;
12783                 }
12784                 {
12785                         uint32_t _flags_save_string = ndr->flags;
12786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12788                         if (_ptr_vendor_setup) {
12789                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12791                         } else {
12792                                 r->vendor_setup = NULL;
12793                         }
12794                         ndr->flags = _flags_save_string;
12795                 }
12796                 {
12797                         uint32_t _flags_save_string_array = ndr->flags;
12798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12799                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12800                         if (_ptr_color_profiles) {
12801                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12802                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12803                         } else {
12804                                 r->color_profiles = NULL;
12805                         }
12806                         ndr->flags = _flags_save_string_array;
12807                 }
12808                 {
12809                         uint32_t _flags_save_string = ndr->flags;
12810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12812                         if (_ptr_inf_path) {
12813                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12815                         } else {
12816                                 r->inf_path = NULL;
12817                         }
12818                         ndr->flags = _flags_save_string;
12819                 }
12820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12821                 {
12822                         uint32_t _flags_save_string_array = ndr->flags;
12823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12824                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12825                         if (_ptr_core_driver_dependencies) {
12826                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12827                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12828                         } else {
12829                                 r->core_driver_dependencies = NULL;
12830                         }
12831                         ndr->flags = _flags_save_string_array;
12832                 }
12833                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12834                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12835         }
12836         if (ndr_flags & NDR_BUFFERS) {
12837                 {
12838                         uint32_t _flags_save_string = ndr->flags;
12839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12840                         if (r->driver_name) {
12841                                 uint32_t _relative_save_offset;
12842                                 _relative_save_offset = ndr->offset;
12843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12844                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12845                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12848                                 ndr->offset = _relative_save_offset;
12849                         }
12850                         ndr->flags = _flags_save_string;
12851                 }
12852                 {
12853                         uint32_t _flags_save_string = ndr->flags;
12854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12855                         if (r->architecture) {
12856                                 uint32_t _relative_save_offset;
12857                                 _relative_save_offset = ndr->offset;
12858                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12859                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12860                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12861                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12862                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12863                                 ndr->offset = _relative_save_offset;
12864                         }
12865                         ndr->flags = _flags_save_string;
12866                 }
12867                 {
12868                         uint32_t _flags_save_string = ndr->flags;
12869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12870                         if (r->driver_path) {
12871                                 uint32_t _relative_save_offset;
12872                                 _relative_save_offset = ndr->offset;
12873                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12874                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12875                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12876                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12877                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12878                                 ndr->offset = _relative_save_offset;
12879                         }
12880                         ndr->flags = _flags_save_string;
12881                 }
12882                 {
12883                         uint32_t _flags_save_string = ndr->flags;
12884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12885                         if (r->data_file) {
12886                                 uint32_t _relative_save_offset;
12887                                 _relative_save_offset = ndr->offset;
12888                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12889                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12890                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12891                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12892                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12893                                 ndr->offset = _relative_save_offset;
12894                         }
12895                         ndr->flags = _flags_save_string;
12896                 }
12897                 {
12898                         uint32_t _flags_save_string = ndr->flags;
12899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12900                         if (r->config_file) {
12901                                 uint32_t _relative_save_offset;
12902                                 _relative_save_offset = ndr->offset;
12903                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12904                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12905                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12906                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12907                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12908                                 ndr->offset = _relative_save_offset;
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->help_file) {
12916                                 uint32_t _relative_save_offset;
12917                                 _relative_save_offset = ndr->offset;
12918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12919                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12920                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12923                                 ndr->offset = _relative_save_offset;
12924                         }
12925                         ndr->flags = _flags_save_string;
12926                 }
12927                 {
12928                         uint32_t _flags_save_string = ndr->flags;
12929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12930                         if (r->monitor_name) {
12931                                 uint32_t _relative_save_offset;
12932                                 _relative_save_offset = ndr->offset;
12933                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12934                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12935                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12936                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12937                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12938                                 ndr->offset = _relative_save_offset;
12939                         }
12940                         ndr->flags = _flags_save_string;
12941                 }
12942                 {
12943                         uint32_t _flags_save_string = ndr->flags;
12944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12945                         if (r->default_datatype) {
12946                                 uint32_t _relative_save_offset;
12947                                 _relative_save_offset = ndr->offset;
12948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12949                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12950                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12953                                 ndr->offset = _relative_save_offset;
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                                 uint32_t _relative_save_offset;
12962                                 _relative_save_offset = ndr->offset;
12963                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12964                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12965                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12966                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12967                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12968                                 ndr->offset = _relative_save_offset;
12969                         }
12970                         ndr->flags = _flags_save_string_array;
12971                 }
12972                 {
12973                         uint32_t _flags_save_string_array = ndr->flags;
12974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12975                         if (r->previous_names) {
12976                                 uint32_t _relative_save_offset;
12977                                 _relative_save_offset = ndr->offset;
12978                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12979                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12980                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12981                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12982                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12983                                 ndr->offset = _relative_save_offset;
12984                         }
12985                         ndr->flags = _flags_save_string_array;
12986                 }
12987                 {
12988                         uint32_t _flags_save_string = ndr->flags;
12989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12990                         if (r->manufacturer_name) {
12991                                 uint32_t _relative_save_offset;
12992                                 _relative_save_offset = ndr->offset;
12993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12994                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12995                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12998                                 ndr->offset = _relative_save_offset;
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->manufacturer_url) {
13006                                 uint32_t _relative_save_offset;
13007                                 _relative_save_offset = ndr->offset;
13008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13009                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13010                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13013                                 ndr->offset = _relative_save_offset;
13014                         }
13015                         ndr->flags = _flags_save_string;
13016                 }
13017                 {
13018                         uint32_t _flags_save_string = ndr->flags;
13019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13020                         if (r->hardware_id) {
13021                                 uint32_t _relative_save_offset;
13022                                 _relative_save_offset = ndr->offset;
13023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13024                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13025                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13026                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13028                                 ndr->offset = _relative_save_offset;
13029                         }
13030                         ndr->flags = _flags_save_string;
13031                 }
13032                 {
13033                         uint32_t _flags_save_string = ndr->flags;
13034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13035                         if (r->provider) {
13036                                 uint32_t _relative_save_offset;
13037                                 _relative_save_offset = ndr->offset;
13038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13039                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13040                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13043                                 ndr->offset = _relative_save_offset;
13044                         }
13045                         ndr->flags = _flags_save_string;
13046                 }
13047                 {
13048                         uint32_t _flags_save_string = ndr->flags;
13049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13050                         if (r->print_processor) {
13051                                 uint32_t _relative_save_offset;
13052                                 _relative_save_offset = ndr->offset;
13053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13054                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13055                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13058                                 ndr->offset = _relative_save_offset;
13059                         }
13060                         ndr->flags = _flags_save_string;
13061                 }
13062                 {
13063                         uint32_t _flags_save_string = ndr->flags;
13064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13065                         if (r->vendor_setup) {
13066                                 uint32_t _relative_save_offset;
13067                                 _relative_save_offset = ndr->offset;
13068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13069                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13070                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13071                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13073                                 ndr->offset = _relative_save_offset;
13074                         }
13075                         ndr->flags = _flags_save_string;
13076                 }
13077                 {
13078                         uint32_t _flags_save_string_array = ndr->flags;
13079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13080                         if (r->color_profiles) {
13081                                 uint32_t _relative_save_offset;
13082                                 _relative_save_offset = ndr->offset;
13083                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13084                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13085                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13086                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13087                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13088                                 ndr->offset = _relative_save_offset;
13089                         }
13090                         ndr->flags = _flags_save_string_array;
13091                 }
13092                 {
13093                         uint32_t _flags_save_string = ndr->flags;
13094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13095                         if (r->inf_path) {
13096                                 uint32_t _relative_save_offset;
13097                                 _relative_save_offset = ndr->offset;
13098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13099                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13100                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13103                                 ndr->offset = _relative_save_offset;
13104                         }
13105                         ndr->flags = _flags_save_string;
13106                 }
13107                 {
13108                         uint32_t _flags_save_string_array = ndr->flags;
13109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13110                         if (r->core_driver_dependencies) {
13111                                 uint32_t _relative_save_offset;
13112                                 _relative_save_offset = ndr->offset;
13113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13114                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13115                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13116                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13118                                 ndr->offset = _relative_save_offset;
13119                         }
13120                         ndr->flags = _flags_save_string_array;
13121                 }
13122         }
13123         return NDR_ERR_SUCCESS;
13124 }
13125
13126 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13127 {
13128         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13129         ndr->depth++;
13130         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13131         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13132         ndr->depth++;
13133         if (r->driver_name) {
13134                 ndr_print_string(ndr, "driver_name", r->driver_name);
13135         }
13136         ndr->depth--;
13137         ndr_print_ptr(ndr, "architecture", r->architecture);
13138         ndr->depth++;
13139         if (r->architecture) {
13140                 ndr_print_string(ndr, "architecture", r->architecture);
13141         }
13142         ndr->depth--;
13143         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13144         ndr->depth++;
13145         if (r->driver_path) {
13146                 ndr_print_string(ndr, "driver_path", r->driver_path);
13147         }
13148         ndr->depth--;
13149         ndr_print_ptr(ndr, "data_file", r->data_file);
13150         ndr->depth++;
13151         if (r->data_file) {
13152                 ndr_print_string(ndr, "data_file", r->data_file);
13153         }
13154         ndr->depth--;
13155         ndr_print_ptr(ndr, "config_file", r->config_file);
13156         ndr->depth++;
13157         if (r->config_file) {
13158                 ndr_print_string(ndr, "config_file", r->config_file);
13159         }
13160         ndr->depth--;
13161         ndr_print_ptr(ndr, "help_file", r->help_file);
13162         ndr->depth++;
13163         if (r->help_file) {
13164                 ndr_print_string(ndr, "help_file", r->help_file);
13165         }
13166         ndr->depth--;
13167         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13168         ndr->depth++;
13169         if (r->monitor_name) {
13170                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13171         }
13172         ndr->depth--;
13173         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13174         ndr->depth++;
13175         if (r->default_datatype) {
13176                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13177         }
13178         ndr->depth--;
13179         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13180         ndr->depth++;
13181         if (r->dependent_files) {
13182                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13183         }
13184         ndr->depth--;
13185         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13186         ndr->depth++;
13187         if (r->previous_names) {
13188                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13189         }
13190         ndr->depth--;
13191         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13192         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13193         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13194         ndr->depth++;
13195         if (r->manufacturer_name) {
13196                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13197         }
13198         ndr->depth--;
13199         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13200         ndr->depth++;
13201         if (r->manufacturer_url) {
13202                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13203         }
13204         ndr->depth--;
13205         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13206         ndr->depth++;
13207         if (r->hardware_id) {
13208                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13209         }
13210         ndr->depth--;
13211         ndr_print_ptr(ndr, "provider", r->provider);
13212         ndr->depth++;
13213         if (r->provider) {
13214                 ndr_print_string(ndr, "provider", r->provider);
13215         }
13216         ndr->depth--;
13217         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13218         ndr->depth++;
13219         if (r->print_processor) {
13220                 ndr_print_string(ndr, "print_processor", r->print_processor);
13221         }
13222         ndr->depth--;
13223         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13224         ndr->depth++;
13225         if (r->vendor_setup) {
13226                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13227         }
13228         ndr->depth--;
13229         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13230         ndr->depth++;
13231         if (r->color_profiles) {
13232                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13233         }
13234         ndr->depth--;
13235         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13236         ndr->depth++;
13237         if (r->inf_path) {
13238                 ndr_print_string(ndr, "inf_path", r->inf_path);
13239         }
13240         ndr->depth--;
13241         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13242         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13243         ndr->depth++;
13244         if (r->core_driver_dependencies) {
13245                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13246         }
13247         ndr->depth--;
13248         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13249         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13250         ndr->depth--;
13251 }
13252
13253 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13254 {
13255         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13256 }
13257
13258 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13259 {
13260         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13261         return NDR_ERR_SUCCESS;
13262 }
13263
13264 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13265 {
13266         uint32_t v;
13267         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13268         *r = v;
13269         return NDR_ERR_SUCCESS;
13270 }
13271
13272 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13273 {
13274         const char *val = NULL;
13275
13276         switch (r) {
13277                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13278                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13279                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13280                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13281                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13282         }
13283         ndr_print_enum(ndr, name, "ENUM", val, r);
13284 }
13285
13286 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13287 {
13288         if (ndr_flags & NDR_SCALARS) {
13289                 NDR_CHECK(ndr_push_align(ndr, 4));
13290                 {
13291                         uint32_t _flags_save_string = ndr->flags;
13292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13293                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13294                         ndr->flags = _flags_save_string;
13295                 }
13296                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13298         }
13299         if (ndr_flags & NDR_BUFFERS) {
13300                 {
13301                         uint32_t _flags_save_string = ndr->flags;
13302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13303                         if (r->file_name) {
13304                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13305                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13306                         }
13307                         ndr->flags = _flags_save_string;
13308                 }
13309         }
13310         return NDR_ERR_SUCCESS;
13311 }
13312
13313 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13314 {
13315         uint32_t _ptr_file_name;
13316         TALLOC_CTX *_mem_save_file_name_0;
13317         if (ndr_flags & NDR_SCALARS) {
13318                 NDR_CHECK(ndr_pull_align(ndr, 4));
13319                 {
13320                         uint32_t _flags_save_string = ndr->flags;
13321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13322                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13323                         if (_ptr_file_name) {
13324                                 NDR_PULL_ALLOC(ndr, r->file_name);
13325                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13326                         } else {
13327                                 r->file_name = NULL;
13328                         }
13329                         ndr->flags = _flags_save_string;
13330                 }
13331                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13333         }
13334         if (ndr_flags & NDR_BUFFERS) {
13335                 {
13336                         uint32_t _flags_save_string = ndr->flags;
13337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13338                         if (r->file_name) {
13339                                 uint32_t _relative_save_offset;
13340                                 _relative_save_offset = ndr->offset;
13341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13342                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13343                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13344                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13346                                 ndr->offset = _relative_save_offset;
13347                         }
13348                         ndr->flags = _flags_save_string;
13349                 }
13350         }
13351         return NDR_ERR_SUCCESS;
13352 }
13353
13354 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13355 {
13356         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13357         ndr->depth++;
13358         ndr_print_ptr(ndr, "file_name", r->file_name);
13359         ndr->depth++;
13360         if (r->file_name) {
13361                 ndr_print_string(ndr, "file_name", r->file_name);
13362         }
13363         ndr->depth--;
13364         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13365         ndr_print_uint32(ndr, "file_version", r->file_version);
13366         ndr->depth--;
13367 }
13368
13369 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13370 {
13371         uint32_t cntr_file_info_1;
13372         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13373         ndr->depth++;
13374         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13375         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13376         ndr->depth++;
13377         if (r->driver_name) {
13378                 ndr_print_string(ndr, "driver_name", r->driver_name);
13379         }
13380         ndr->depth--;
13381         ndr_print_ptr(ndr, "architecture", r->architecture);
13382         ndr->depth++;
13383         if (r->architecture) {
13384                 ndr_print_string(ndr, "architecture", r->architecture);
13385         }
13386         ndr->depth--;
13387         ndr_print_ptr(ndr, "file_info", r->file_info);
13388         ndr->depth++;
13389         if (r->file_info) {
13390                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13391                 ndr->depth++;
13392                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13393                         char *idx_1=NULL;
13394                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13395                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13396                                 free(idx_1);
13397                         }
13398                 }
13399                 ndr->depth--;
13400         }
13401         ndr->depth--;
13402         ndr_print_uint32(ndr, "file_count", r->file_count);
13403         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13404         ndr->depth++;
13405         if (r->monitor_name) {
13406                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13407         }
13408         ndr->depth--;
13409         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13410         ndr->depth++;
13411         if (r->default_datatype) {
13412                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13413         }
13414         ndr->depth--;
13415         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13416         ndr->depth++;
13417         if (r->previous_names) {
13418                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13419         }
13420         ndr->depth--;
13421         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13422         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13423         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13424         ndr->depth++;
13425         if (r->manufacturer_name) {
13426                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13427         }
13428         ndr->depth--;
13429         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13430         ndr->depth++;
13431         if (r->manufacturer_url) {
13432                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13433         }
13434         ndr->depth--;
13435         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13436         ndr->depth++;
13437         if (r->hardware_id) {
13438                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13439         }
13440         ndr->depth--;
13441         ndr_print_ptr(ndr, "provider", r->provider);
13442         ndr->depth++;
13443         if (r->provider) {
13444                 ndr_print_string(ndr, "provider", r->provider);
13445         }
13446         ndr->depth--;
13447         ndr->depth--;
13448 }
13449
13450 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13451 {
13452         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13453 }
13454
13455 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13456 {
13457         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13458         if (ndr_flags & NDR_SCALARS) {
13459                 int level = ndr_push_get_switch_value(ndr, r);
13460                 switch (level) {
13461                         case 1: {
13462                                 NDR_CHECK(ndr_push_align(ndr, 4));
13463                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13464                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13465                         break; }
13466
13467                         case 2: {
13468                                 NDR_CHECK(ndr_push_align(ndr, 4));
13469                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13471                         break; }
13472
13473                         case 3: {
13474                                 NDR_CHECK(ndr_push_align(ndr, 4));
13475                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13476                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13477                         break; }
13478
13479                         case 4: {
13480                                 NDR_CHECK(ndr_push_align(ndr, 4));
13481                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13482                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13483                         break; }
13484
13485                         case 5: {
13486                                 NDR_CHECK(ndr_push_align(ndr, 4));
13487                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13488                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13489                         break; }
13490
13491                         case 6: {
13492                                 NDR_CHECK(ndr_push_align(ndr, 8));
13493                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13494                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13495                         break; }
13496
13497                         case 8: {
13498                                 NDR_CHECK(ndr_push_align(ndr, 8));
13499                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13500                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13501                         break; }
13502
13503                         case 101: {
13504                                 NDR_CHECK(ndr_push_align(ndr, 8));
13505                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13506                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13507                         break; }
13508
13509                         default: {
13510                         break; }
13511
13512                 }
13513         }
13514         if (ndr_flags & NDR_BUFFERS) {
13515                 int level = ndr_push_get_switch_value(ndr, r);
13516                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13517                 switch (level) {
13518                         case 1:
13519                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13520                         break;
13521
13522                         case 2:
13523                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13524                         break;
13525
13526                         case 3:
13527                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13528                         break;
13529
13530                         case 4:
13531                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13532                         break;
13533
13534                         case 5:
13535                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13536                         break;
13537
13538                         case 6:
13539                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13540                         break;
13541
13542                         case 8:
13543                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13544                         break;
13545
13546                         case 101:
13547                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13548                         break;
13549
13550                         default:
13551                         break;
13552
13553                 }
13554         }
13555         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13556         return NDR_ERR_SUCCESS;
13557 }
13558
13559 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13560 {
13561         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13562         int level;
13563         level = ndr_pull_get_switch_value(ndr, r);
13564         if (ndr_flags & NDR_SCALARS) {
13565                 switch (level) {
13566                         case 1: {
13567                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13568                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13569                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13570                         break; }
13571
13572                         case 2: {
13573                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13574                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13575                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13576                         break; }
13577
13578                         case 3: {
13579                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13580                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13581                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13582                         break; }
13583
13584                         case 4: {
13585                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13586                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13587                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13588                         break; }
13589
13590                         case 5: {
13591                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13592                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13593                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13594                         break; }
13595
13596                         case 6: {
13597                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13598                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13599                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13600                         break; }
13601
13602                         case 8: {
13603                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13604                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13605                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13606                         break; }
13607
13608                         case 101: {
13609                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13610                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13611                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13612                         break; }
13613
13614                         default: {
13615                         break; }
13616
13617                 }
13618         }
13619         if (ndr_flags & NDR_BUFFERS) {
13620                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13621                 switch (level) {
13622                         case 1:
13623                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13624                         break;
13625
13626                         case 2:
13627                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13628                         break;
13629
13630                         case 3:
13631                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13632                         break;
13633
13634                         case 4:
13635                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13636                         break;
13637
13638                         case 5:
13639                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13640                         break;
13641
13642                         case 6:
13643                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13644                         break;
13645
13646                         case 8:
13647                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13648                         break;
13649
13650                         case 101:
13651                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13652                         break;
13653
13654                         default:
13655                         break;
13656
13657                 }
13658         }
13659         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13660         return NDR_ERR_SUCCESS;
13661 }
13662
13663 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13664 {
13665         int level;
13666         level = ndr_print_get_switch_value(ndr, r);
13667         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13668         switch (level) {
13669                 case 1:
13670                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13671                 break;
13672
13673                 case 2:
13674                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13675                 break;
13676
13677                 case 3:
13678                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13679                 break;
13680
13681                 case 4:
13682                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13683                 break;
13684
13685                 case 5:
13686                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13687                 break;
13688
13689                 case 6:
13690                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13691                 break;
13692
13693                 case 8:
13694                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13695                 break;
13696
13697                 case 101:
13698                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13699                 break;
13700
13701                 default:
13702                 break;
13703
13704         }
13705 }
13706
13707 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13708 {
13709         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
13710 }
13711
13712 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13713 {
13714         if (ndr_flags & NDR_SCALARS) {
13715                 NDR_CHECK(ndr_push_align(ndr, 4));
13716                 {
13717                         uint32_t _flags_save_string = ndr->flags;
13718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13719                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13720                         ndr->flags = _flags_save_string;
13721                 }
13722         }
13723         if (ndr_flags & NDR_BUFFERS) {
13724         }
13725         return NDR_ERR_SUCCESS;
13726 }
13727
13728 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13729 {
13730         if (ndr_flags & NDR_SCALARS) {
13731                 NDR_CHECK(ndr_pull_align(ndr, 4));
13732                 {
13733                         uint32_t _flags_save_string = ndr->flags;
13734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13735                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13736                         ndr->flags = _flags_save_string;
13737                 }
13738         }
13739         if (ndr_flags & NDR_BUFFERS) {
13740         }
13741         return NDR_ERR_SUCCESS;
13742 }
13743
13744 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13745 {
13746         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13747         ndr->depth++;
13748         ndr_print_string(ndr, "directory_name", r->directory_name);
13749         ndr->depth--;
13750 }
13751
13752 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13753 {
13754         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13755 }
13756
13757 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13758 {
13759         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13760         if (ndr_flags & NDR_SCALARS) {
13761                 int level = ndr_push_get_switch_value(ndr, r);
13762                 switch (level) {
13763                         case 1: {
13764                                 NDR_CHECK(ndr_push_align(ndr, 4));
13765                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13766                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13767                         break; }
13768
13769                         default: {
13770                                 NDR_CHECK(ndr_push_align(ndr, 4));
13771                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13772                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13773                         break; }
13774
13775                 }
13776         }
13777         if (ndr_flags & NDR_BUFFERS) {
13778                 int level = ndr_push_get_switch_value(ndr, r);
13779                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13780                 switch (level) {
13781                         case 1:
13782                         break;
13783
13784                         default:
13785                         break;
13786
13787                 }
13788         }
13789         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13790         return NDR_ERR_SUCCESS;
13791 }
13792
13793 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13794 {
13795         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13796         int level;
13797         level = ndr_pull_get_switch_value(ndr, r);
13798         if (ndr_flags & NDR_SCALARS) {
13799                 switch (level) {
13800                         case 1: {
13801                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13802                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13803                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13804                         break; }
13805
13806                         default: {
13807                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13808                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13809                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13810                         break; }
13811
13812                 }
13813         }
13814         if (ndr_flags & NDR_BUFFERS) {
13815                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13816                 switch (level) {
13817                         case 1:
13818                         break;
13819
13820                         default:
13821                         break;
13822
13823                 }
13824         }
13825         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13826         return NDR_ERR_SUCCESS;
13827 }
13828
13829 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13830 {
13831         int level;
13832         level = ndr_print_get_switch_value(ndr, r);
13833         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13834         switch (level) {
13835                 case 1:
13836                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13837                 break;
13838
13839                 default:
13840                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13841                 break;
13842
13843         }
13844 }
13845
13846 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13847 {
13848         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13849 }
13850
13851 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13852 {
13853         if (ndr_flags & NDR_SCALARS) {
13854                 NDR_CHECK(ndr_push_align(ndr, 4));
13855                 {
13856                         uint32_t _flags_save_string = ndr->flags;
13857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13858                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13859                         ndr->flags = _flags_save_string;
13860                 }
13861         }
13862         if (ndr_flags & NDR_BUFFERS) {
13863                 {
13864                         uint32_t _flags_save_string = ndr->flags;
13865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13866                         if (r->print_processor_name) {
13867                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13868                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13869                         }
13870                         ndr->flags = _flags_save_string;
13871                 }
13872         }
13873         return NDR_ERR_SUCCESS;
13874 }
13875
13876 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13877 {
13878         uint32_t _ptr_print_processor_name;
13879         TALLOC_CTX *_mem_save_print_processor_name_0;
13880         if (ndr_flags & NDR_SCALARS) {
13881                 NDR_CHECK(ndr_pull_align(ndr, 4));
13882                 {
13883                         uint32_t _flags_save_string = ndr->flags;
13884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13885                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13886                         if (_ptr_print_processor_name) {
13887                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13888                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13889                         } else {
13890                                 r->print_processor_name = NULL;
13891                         }
13892                         ndr->flags = _flags_save_string;
13893                 }
13894         }
13895         if (ndr_flags & NDR_BUFFERS) {
13896                 {
13897                         uint32_t _flags_save_string = ndr->flags;
13898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13899                         if (r->print_processor_name) {
13900                                 uint32_t _relative_save_offset;
13901                                 _relative_save_offset = ndr->offset;
13902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13903                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13904                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13907                                 ndr->offset = _relative_save_offset;
13908                         }
13909                         ndr->flags = _flags_save_string;
13910                 }
13911         }
13912         return NDR_ERR_SUCCESS;
13913 }
13914
13915 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13916 {
13917         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13918         ndr->depth++;
13919         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13920         ndr->depth++;
13921         if (r->print_processor_name) {
13922                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13923         }
13924         ndr->depth--;
13925         ndr->depth--;
13926 }
13927
13928 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13929 {
13930         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13931 }
13932
13933 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13934 {
13935         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13936         if (ndr_flags & NDR_SCALARS) {
13937                 int level = ndr_push_get_switch_value(ndr, r);
13938                 switch (level) {
13939                         case 1: {
13940                                 NDR_CHECK(ndr_push_align(ndr, 4));
13941                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13942                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13943                         break; }
13944
13945                         default: {
13946                         break; }
13947
13948                 }
13949         }
13950         if (ndr_flags & NDR_BUFFERS) {
13951                 int level = ndr_push_get_switch_value(ndr, r);
13952                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13953                 switch (level) {
13954                         case 1:
13955                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13956                         break;
13957
13958                         default:
13959                         break;
13960
13961                 }
13962         }
13963         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13964         return NDR_ERR_SUCCESS;
13965 }
13966
13967 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13968 {
13969         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13970         int level;
13971         level = ndr_pull_get_switch_value(ndr, r);
13972         if (ndr_flags & NDR_SCALARS) {
13973                 switch (level) {
13974                         case 1: {
13975                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13976                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13977                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13978                         break; }
13979
13980                         default: {
13981                         break; }
13982
13983                 }
13984         }
13985         if (ndr_flags & NDR_BUFFERS) {
13986                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13987                 switch (level) {
13988                         case 1:
13989                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13990                         break;
13991
13992                         default:
13993                         break;
13994
13995                 }
13996         }
13997         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13998         return NDR_ERR_SUCCESS;
13999 }
14000
14001 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14002 {
14003         int level;
14004         level = ndr_print_get_switch_value(ndr, r);
14005         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14006         switch (level) {
14007                 case 1:
14008                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14009                 break;
14010
14011                 default:
14012                 break;
14013
14014         }
14015 }
14016
14017 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14018 {
14019         if (ndr_flags & NDR_SCALARS) {
14020                 NDR_CHECK(ndr_push_align(ndr, 4));
14021                 {
14022                         uint32_t _flags_save_string = ndr->flags;
14023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14024                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14025                         ndr->flags = _flags_save_string;
14026                 }
14027         }
14028         if (ndr_flags & NDR_BUFFERS) {
14029         }
14030         return NDR_ERR_SUCCESS;
14031 }
14032
14033 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14034 {
14035         if (ndr_flags & NDR_SCALARS) {
14036                 NDR_CHECK(ndr_pull_align(ndr, 4));
14037                 {
14038                         uint32_t _flags_save_string = ndr->flags;
14039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14040                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14041                         ndr->flags = _flags_save_string;
14042                 }
14043         }
14044         if (ndr_flags & NDR_BUFFERS) {
14045         }
14046         return NDR_ERR_SUCCESS;
14047 }
14048
14049 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14050 {
14051         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14052         ndr->depth++;
14053         ndr_print_string(ndr, "directory_name", r->directory_name);
14054         ndr->depth--;
14055 }
14056
14057 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14058 {
14059         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14060 }
14061
14062 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14063 {
14064         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14065         if (ndr_flags & NDR_SCALARS) {
14066                 int level = ndr_push_get_switch_value(ndr, r);
14067                 switch (level) {
14068                         case 1: {
14069                                 NDR_CHECK(ndr_push_align(ndr, 4));
14070                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14071                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14072                         break; }
14073
14074                         default: {
14075                                 NDR_CHECK(ndr_push_align(ndr, 4));
14076                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14077                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14078                         break; }
14079
14080                 }
14081         }
14082         if (ndr_flags & NDR_BUFFERS) {
14083                 int level = ndr_push_get_switch_value(ndr, r);
14084                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14085                 switch (level) {
14086                         case 1:
14087                         break;
14088
14089                         default:
14090                         break;
14091
14092                 }
14093         }
14094         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14095         return NDR_ERR_SUCCESS;
14096 }
14097
14098 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14099 {
14100         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14101         int level;
14102         level = ndr_pull_get_switch_value(ndr, r);
14103         if (ndr_flags & NDR_SCALARS) {
14104                 switch (level) {
14105                         case 1: {
14106                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14107                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14108                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14109                         break; }
14110
14111                         default: {
14112                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14113                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14114                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14115                         break; }
14116
14117                 }
14118         }
14119         if (ndr_flags & NDR_BUFFERS) {
14120                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14121                 switch (level) {
14122                         case 1:
14123                         break;
14124
14125                         default:
14126                         break;
14127
14128                 }
14129         }
14130         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14131         return NDR_ERR_SUCCESS;
14132 }
14133
14134 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14135 {
14136         int level;
14137         level = ndr_print_get_switch_value(ndr, r);
14138         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14139         switch (level) {
14140                 case 1:
14141                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14142                 break;
14143
14144                 default:
14145                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14146                 break;
14147
14148         }
14149 }
14150
14151 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14152 {
14153         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14154 }
14155
14156 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14157 {
14158         if (ndr_flags & NDR_SCALARS) {
14159                 NDR_CHECK(ndr_push_align(ndr, 4));
14160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14161                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14162                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14163         }
14164         if (ndr_flags & NDR_BUFFERS) {
14165                 if (r->document_name) {
14166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14168                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14170                 }
14171                 if (r->output_file) {
14172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14174                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14175                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14176                 }
14177                 if (r->datatype) {
14178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14180                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14181                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14182                 }
14183         }
14184         return NDR_ERR_SUCCESS;
14185 }
14186
14187 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14188 {
14189         uint32_t _ptr_document_name;
14190         TALLOC_CTX *_mem_save_document_name_0;
14191         uint32_t _ptr_output_file;
14192         TALLOC_CTX *_mem_save_output_file_0;
14193         uint32_t _ptr_datatype;
14194         TALLOC_CTX *_mem_save_datatype_0;
14195         if (ndr_flags & NDR_SCALARS) {
14196                 NDR_CHECK(ndr_pull_align(ndr, 4));
14197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14198                 if (_ptr_document_name) {
14199                         NDR_PULL_ALLOC(ndr, r->document_name);
14200                 } else {
14201                         r->document_name = NULL;
14202                 }
14203                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14204                 if (_ptr_output_file) {
14205                         NDR_PULL_ALLOC(ndr, r->output_file);
14206                 } else {
14207                         r->output_file = NULL;
14208                 }
14209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14210                 if (_ptr_datatype) {
14211                         NDR_PULL_ALLOC(ndr, r->datatype);
14212                 } else {
14213                         r->datatype = NULL;
14214                 }
14215         }
14216         if (ndr_flags & NDR_BUFFERS) {
14217                 if (r->document_name) {
14218                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14219                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14222                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
14224                         }
14225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14228                 }
14229                 if (r->output_file) {
14230                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14231                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14234                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14235                                 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));
14236                         }
14237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14240                 }
14241                 if (r->datatype) {
14242                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14243                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14246                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14247                                 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));
14248                         }
14249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14252                 }
14253         }
14254         return NDR_ERR_SUCCESS;
14255 }
14256
14257 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14258 {
14259         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14260         ndr->depth++;
14261         ndr_print_ptr(ndr, "document_name", r->document_name);
14262         ndr->depth++;
14263         if (r->document_name) {
14264                 ndr_print_string(ndr, "document_name", r->document_name);
14265         }
14266         ndr->depth--;
14267         ndr_print_ptr(ndr, "output_file", r->output_file);
14268         ndr->depth++;
14269         if (r->output_file) {
14270                 ndr_print_string(ndr, "output_file", r->output_file);
14271         }
14272         ndr->depth--;
14273         ndr_print_ptr(ndr, "datatype", r->datatype);
14274         ndr->depth++;
14275         if (r->datatype) {
14276                 ndr_print_string(ndr, "datatype", r->datatype);
14277         }
14278         ndr->depth--;
14279         ndr->depth--;
14280 }
14281
14282 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14283 {
14284         if (ndr_flags & NDR_SCALARS) {
14285                 int level = ndr_push_get_switch_value(ndr, r);
14286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14287                 switch (level) {
14288                         case 1: {
14289                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14290                         break; }
14291
14292                         case 2: {
14293                         break; }
14294
14295                         case 3: {
14296                         break; }
14297
14298                         default: {
14299                         break; }
14300
14301                 }
14302         }
14303         if (ndr_flags & NDR_BUFFERS) {
14304                 int level = ndr_push_get_switch_value(ndr, r);
14305                 switch (level) {
14306                         case 1:
14307                                 if (r->info1) {
14308                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14309                                 }
14310                         break;
14311
14312                         case 2:
14313                         break;
14314
14315                         case 3:
14316                         break;
14317
14318                         default:
14319                         break;
14320
14321                 }
14322         }
14323         return NDR_ERR_SUCCESS;
14324 }
14325
14326 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14327 {
14328         int level;
14329         uint32_t _level;
14330         TALLOC_CTX *_mem_save_info1_0;
14331         level = ndr_pull_get_switch_value(ndr, r);
14332         if (ndr_flags & NDR_SCALARS) {
14333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14334                 if (_level != level) {
14335                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14336                 }
14337                 switch (level) {
14338                         case 1: {
14339                                 uint32_t _ptr_info1;
14340                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14341                                 if (_ptr_info1) {
14342                                         NDR_PULL_ALLOC(ndr, r->info1);
14343                                 } else {
14344                                         r->info1 = NULL;
14345                                 }
14346                         break; }
14347
14348                         case 2: {
14349                         break; }
14350
14351                         case 3: {
14352                         break; }
14353
14354                         default: {
14355                         break; }
14356
14357                 }
14358         }
14359         if (ndr_flags & NDR_BUFFERS) {
14360                 switch (level) {
14361                         case 1:
14362                                 if (r->info1) {
14363                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14364                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14365                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14366                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14367                                 }
14368                         break;
14369
14370                         case 2:
14371                         break;
14372
14373                         case 3:
14374                         break;
14375
14376                         default:
14377                         break;
14378
14379                 }
14380         }
14381         return NDR_ERR_SUCCESS;
14382 }
14383
14384 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14385 {
14386         int level;
14387         level = ndr_print_get_switch_value(ndr, r);
14388         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14389         switch (level) {
14390                 case 1:
14391                         ndr_print_ptr(ndr, "info1", r->info1);
14392                         ndr->depth++;
14393                         if (r->info1) {
14394                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14395                         }
14396                         ndr->depth--;
14397                 break;
14398
14399                 case 2:
14400                 break;
14401
14402                 case 3:
14403                 break;
14404
14405                 default:
14406                 break;
14407
14408         }
14409 }
14410
14411 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14412 {
14413         if (ndr_flags & NDR_SCALARS) {
14414                 NDR_CHECK(ndr_push_align(ndr, 4));
14415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14420                 {
14421                         uint32_t _flags_save_string = ndr->flags;
14422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14423                         {
14424                                 struct ndr_push *_ndr_extra_string;
14425                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14426                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14427                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14428                         }
14429                         ndr->flags = _flags_save_string;
14430                 }
14431         }
14432         if (ndr_flags & NDR_BUFFERS) {
14433         }
14434         return NDR_ERR_SUCCESS;
14435 }
14436
14437 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14438 {
14439         if (ndr_flags & NDR_SCALARS) {
14440                 NDR_CHECK(ndr_pull_align(ndr, 4));
14441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14446                 {
14447                         uint32_t _flags_save_string = ndr->flags;
14448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14449                         {
14450                                 struct ndr_pull *_ndr_extra_string;
14451                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14452                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14453                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14454                         }
14455                         ndr->flags = _flags_save_string;
14456                 }
14457         }
14458         if (ndr_flags & NDR_BUFFERS) {
14459         }
14460         return NDR_ERR_SUCCESS;
14461 }
14462
14463 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14464 {
14465         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14466         ndr->depth++;
14467         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);
14468         ndr_print_uint32(ndr, "major", r->major);
14469         ndr_print_uint32(ndr, "minor", r->minor);
14470         ndr_print_uint32(ndr, "build", r->build);
14471         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14472         ndr_print_string(ndr, "extra_string", r->extra_string);
14473         ndr->depth--;
14474 }
14475
14476 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14477 {
14478         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14479 }
14480
14481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14482 {
14483         if (ndr_flags & NDR_SCALARS) {
14484                 NDR_CHECK(ndr_push_align(ndr, 4));
14485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14490                 {
14491                         uint32_t _flags_save_string = ndr->flags;
14492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14493                         {
14494                                 struct ndr_push *_ndr_extra_string;
14495                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14496                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14497                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14498                         }
14499                         ndr->flags = _flags_save_string;
14500                 }
14501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14503         }
14504         if (ndr_flags & NDR_BUFFERS) {
14505         }
14506         return NDR_ERR_SUCCESS;
14507 }
14508
14509 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14510 {
14511         if (ndr_flags & NDR_SCALARS) {
14512                 NDR_CHECK(ndr_pull_align(ndr, 4));
14513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14518                 {
14519                         uint32_t _flags_save_string = ndr->flags;
14520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14521                         {
14522                                 struct ndr_pull *_ndr_extra_string;
14523                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14524                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14525                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14526                         }
14527                         ndr->flags = _flags_save_string;
14528                 }
14529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14531         }
14532         if (ndr_flags & NDR_BUFFERS) {
14533         }
14534         return NDR_ERR_SUCCESS;
14535 }
14536
14537 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14538 {
14539         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14540         ndr->depth++;
14541         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);
14542         ndr_print_uint32(ndr, "major", r->major);
14543         ndr_print_uint32(ndr, "minor", r->minor);
14544         ndr_print_uint32(ndr, "build", r->build);
14545         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14546         ndr_print_string(ndr, "extra_string", r->extra_string);
14547         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14548         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14549         ndr->depth--;
14550 }
14551
14552 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14553 {
14554         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14555 }
14556
14557 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14558 {
14559         if (ndr_flags & NDR_SCALARS) {
14560                 int level = ndr_push_get_switch_value(ndr, r);
14561                 switch (level) {
14562                         case REG_NONE: {
14563                         break; }
14564
14565                         case REG_SZ: {
14566                                 {
14567                                         uint32_t _flags_save_string = ndr->flags;
14568                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14569                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14570                                         ndr->flags = _flags_save_string;
14571                                 }
14572                         break; }
14573
14574                         case REG_BINARY: {
14575                                 {
14576                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14577                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14578                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14579                                         ndr->flags = _flags_save_DATA_BLOB;
14580                                 }
14581                         break; }
14582
14583                         case REG_DWORD: {
14584                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14585                         break; }
14586
14587                         case REG_MULTI_SZ: {
14588                                 {
14589                                         uint32_t _flags_save_string_array = ndr->flags;
14590                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14591                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14592                                         ndr->flags = _flags_save_string_array;
14593                                 }
14594                         break; }
14595
14596                         default: {
14597                                 {
14598                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14599                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14600                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14601                                         ndr->flags = _flags_save_DATA_BLOB;
14602                                 }
14603                         break; }
14604
14605                 }
14606         }
14607         if (ndr_flags & NDR_BUFFERS) {
14608                 int level = ndr_push_get_switch_value(ndr, r);
14609                 switch (level) {
14610                         case REG_NONE:
14611                         break;
14612
14613                         case REG_SZ:
14614                         break;
14615
14616                         case REG_BINARY:
14617                         break;
14618
14619                         case REG_DWORD:
14620                         break;
14621
14622                         case REG_MULTI_SZ:
14623                         break;
14624
14625                         default:
14626                         break;
14627
14628                 }
14629         }
14630         return NDR_ERR_SUCCESS;
14631 }
14632
14633 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14634 {
14635         int level;
14636         level = ndr_pull_get_switch_value(ndr, r);
14637         if (ndr_flags & NDR_SCALARS) {
14638                 switch (level) {
14639                         case REG_NONE: {
14640                         break; }
14641
14642                         case REG_SZ: {
14643                                 {
14644                                         uint32_t _flags_save_string = ndr->flags;
14645                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14646                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14647                                         ndr->flags = _flags_save_string;
14648                                 }
14649                         break; }
14650
14651                         case REG_BINARY: {
14652                                 {
14653                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14654                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14655                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14656                                         ndr->flags = _flags_save_DATA_BLOB;
14657                                 }
14658                         break; }
14659
14660                         case REG_DWORD: {
14661                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14662                         break; }
14663
14664                         case REG_MULTI_SZ: {
14665                                 {
14666                                         uint32_t _flags_save_string_array = ndr->flags;
14667                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14668                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14669                                         ndr->flags = _flags_save_string_array;
14670                                 }
14671                         break; }
14672
14673                         default: {
14674                                 {
14675                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14676                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14677                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14678                                         ndr->flags = _flags_save_DATA_BLOB;
14679                                 }
14680                         break; }
14681
14682                 }
14683         }
14684         if (ndr_flags & NDR_BUFFERS) {
14685                 switch (level) {
14686                         case REG_NONE:
14687                         break;
14688
14689                         case REG_SZ:
14690                         break;
14691
14692                         case REG_BINARY:
14693                         break;
14694
14695                         case REG_DWORD:
14696                         break;
14697
14698                         case REG_MULTI_SZ:
14699                         break;
14700
14701                         default:
14702                         break;
14703
14704                 }
14705         }
14706         return NDR_ERR_SUCCESS;
14707 }
14708
14709 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14710 {
14711         int level;
14712         level = ndr_print_get_switch_value(ndr, r);
14713         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14714         switch (level) {
14715                 case REG_NONE:
14716                 break;
14717
14718                 case REG_SZ:
14719                         ndr_print_string(ndr, "string", r->string);
14720                 break;
14721
14722                 case REG_BINARY:
14723                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14724                 break;
14725
14726                 case REG_DWORD:
14727                         ndr_print_uint32(ndr, "value", r->value);
14728                 break;
14729
14730                 case REG_MULTI_SZ:
14731                         ndr_print_string_array(ndr, "string_array", r->string_array);
14732                 break;
14733
14734                 default:
14735                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14736                 break;
14737
14738         }
14739 }
14740
14741 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14742 {
14743         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14744 }
14745
14746 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14747 {
14748         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14749         return NDR_ERR_SUCCESS;
14750 }
14751
14752 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14753 {
14754         uint32_t v;
14755         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14756         *r = v;
14757         return NDR_ERR_SUCCESS;
14758 }
14759
14760 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14761 {
14762         const char *val = NULL;
14763
14764         switch (r) {
14765                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14766                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14767                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14768         }
14769         ndr_print_enum(ndr, name, "ENUM", val, r);
14770 }
14771
14772 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14773 {
14774         if (ndr_flags & NDR_SCALARS) {
14775                 NDR_CHECK(ndr_push_align(ndr, 4));
14776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14778         }
14779         if (ndr_flags & NDR_BUFFERS) {
14780         }
14781         return NDR_ERR_SUCCESS;
14782 }
14783
14784 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14785 {
14786         if (ndr_flags & NDR_SCALARS) {
14787                 NDR_CHECK(ndr_pull_align(ndr, 4));
14788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14790         }
14791         if (ndr_flags & NDR_BUFFERS) {
14792         }
14793         return NDR_ERR_SUCCESS;
14794 }
14795
14796 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14797 {
14798         ndr_print_struct(ndr, name, "spoolss_FormSize");
14799         ndr->depth++;
14800         ndr_print_uint32(ndr, "width", r->width);
14801         ndr_print_uint32(ndr, "height", r->height);
14802         ndr->depth--;
14803 }
14804
14805 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14806 {
14807         if (ndr_flags & NDR_SCALARS) {
14808                 NDR_CHECK(ndr_push_align(ndr, 4));
14809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14813         }
14814         if (ndr_flags & NDR_BUFFERS) {
14815         }
14816         return NDR_ERR_SUCCESS;
14817 }
14818
14819 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14820 {
14821         if (ndr_flags & NDR_SCALARS) {
14822                 NDR_CHECK(ndr_pull_align(ndr, 4));
14823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14827         }
14828         if (ndr_flags & NDR_BUFFERS) {
14829         }
14830         return NDR_ERR_SUCCESS;
14831 }
14832
14833 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14834 {
14835         ndr_print_struct(ndr, name, "spoolss_FormArea");
14836         ndr->depth++;
14837         ndr_print_uint32(ndr, "left", r->left);
14838         ndr_print_uint32(ndr, "top", r->top);
14839         ndr_print_uint32(ndr, "right", r->right);
14840         ndr_print_uint32(ndr, "bottom", r->bottom);
14841         ndr->depth--;
14842 }
14843
14844 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14845 {
14846         if (ndr_flags & NDR_SCALARS) {
14847                 NDR_CHECK(ndr_push_align(ndr, 4));
14848                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14849                 {
14850                         uint32_t _flags_save_string = ndr->flags;
14851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14852                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14853                         ndr->flags = _flags_save_string;
14854                 }
14855                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14856                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14857         }
14858         if (ndr_flags & NDR_BUFFERS) {
14859                 {
14860                         uint32_t _flags_save_string = ndr->flags;
14861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14862                         if (r->form_name) {
14863                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14864                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14865                         }
14866                         ndr->flags = _flags_save_string;
14867                 }
14868         }
14869         return NDR_ERR_SUCCESS;
14870 }
14871
14872 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14873 {
14874         uint32_t _ptr_form_name;
14875         TALLOC_CTX *_mem_save_form_name_0;
14876         if (ndr_flags & NDR_SCALARS) {
14877                 NDR_CHECK(ndr_pull_align(ndr, 4));
14878                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14879                 {
14880                         uint32_t _flags_save_string = ndr->flags;
14881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14883                         if (_ptr_form_name) {
14884                                 NDR_PULL_ALLOC(ndr, r->form_name);
14885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14886                         } else {
14887                                 r->form_name = NULL;
14888                         }
14889                         ndr->flags = _flags_save_string;
14890                 }
14891                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14892                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14893         }
14894         if (ndr_flags & NDR_BUFFERS) {
14895                 {
14896                         uint32_t _flags_save_string = ndr->flags;
14897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14898                         if (r->form_name) {
14899                                 uint32_t _relative_save_offset;
14900                                 _relative_save_offset = ndr->offset;
14901                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14902                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14903                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14904                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14905                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14906                                 ndr->offset = _relative_save_offset;
14907                         }
14908                         ndr->flags = _flags_save_string;
14909                 }
14910         }
14911         return NDR_ERR_SUCCESS;
14912 }
14913
14914 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14915 {
14916         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14917         ndr->depth++;
14918         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14919         ndr_print_ptr(ndr, "form_name", r->form_name);
14920         ndr->depth++;
14921         if (r->form_name) {
14922                 ndr_print_string(ndr, "form_name", r->form_name);
14923         }
14924         ndr->depth--;
14925         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14926         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14927         ndr->depth--;
14928 }
14929
14930 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14931 {
14932         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14933 }
14934
14935 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14936 {
14937         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14938         return NDR_ERR_SUCCESS;
14939 }
14940
14941 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14942 {
14943         uint32_t v;
14944         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14945         *r = v;
14946         return NDR_ERR_SUCCESS;
14947 }
14948
14949 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14950 {
14951         ndr_print_uint32(ndr, name, r);
14952         ndr->depth++;
14953         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14954         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14955         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14956         ndr->depth--;
14957 }
14958
14959 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14960 {
14961         if (ndr_flags & NDR_SCALARS) {
14962                 NDR_CHECK(ndr_push_align(ndr, 4));
14963                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14964                 {
14965                         uint32_t _flags_save_string = ndr->flags;
14966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14967                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14968                         ndr->flags = _flags_save_string;
14969                 }
14970                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14971                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14972                 {
14973                         uint32_t _flags_save_string = ndr->flags;
14974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14976                         ndr->flags = _flags_save_string;
14977                 }
14978                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14979                 {
14980                         uint32_t _flags_save_string = ndr->flags;
14981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14982                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14983                         ndr->flags = _flags_save_string;
14984                 }
14985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14986                 {
14987                         uint32_t _flags_save_string = ndr->flags;
14988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14989                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
14990                         ndr->flags = _flags_save_string;
14991                 }
14992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14993         }
14994         if (ndr_flags & NDR_BUFFERS) {
14995                 {
14996                         uint32_t _flags_save_string = ndr->flags;
14997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14998                         if (r->form_name) {
14999                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15000                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15001                         }
15002                         ndr->flags = _flags_save_string;
15003                 }
15004                 {
15005                         uint32_t _flags_save_string = ndr->flags;
15006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15007                         if (r->keyword) {
15008                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15009                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15010                         }
15011                         ndr->flags = _flags_save_string;
15012                 }
15013                 {
15014                         uint32_t _flags_save_string = ndr->flags;
15015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15016                         if (r->mui_dll) {
15017                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15018                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15019                         }
15020                         ndr->flags = _flags_save_string;
15021                 }
15022                 {
15023                         uint32_t _flags_save_string = ndr->flags;
15024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15025                         if (r->display_name) {
15026                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15027                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15028                         }
15029                         ndr->flags = _flags_save_string;
15030                 }
15031         }
15032         return NDR_ERR_SUCCESS;
15033 }
15034
15035 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15036 {
15037         uint32_t _ptr_form_name;
15038         TALLOC_CTX *_mem_save_form_name_0;
15039         uint32_t _ptr_keyword;
15040         TALLOC_CTX *_mem_save_keyword_0;
15041         uint32_t _ptr_mui_dll;
15042         TALLOC_CTX *_mem_save_mui_dll_0;
15043         uint32_t _ptr_display_name;
15044         TALLOC_CTX *_mem_save_display_name_0;
15045         if (ndr_flags & NDR_SCALARS) {
15046                 NDR_CHECK(ndr_pull_align(ndr, 4));
15047                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15048                 {
15049                         uint32_t _flags_save_string = ndr->flags;
15050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15051                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15052                         if (_ptr_form_name) {
15053                                 NDR_PULL_ALLOC(ndr, r->form_name);
15054                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15055                         } else {
15056                                 r->form_name = NULL;
15057                         }
15058                         ndr->flags = _flags_save_string;
15059                 }
15060                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15061                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15062                 {
15063                         uint32_t _flags_save_string = ndr->flags;
15064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15065                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15066                         if (_ptr_keyword) {
15067                                 NDR_PULL_ALLOC(ndr, r->keyword);
15068                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15069                         } else {
15070                                 r->keyword = NULL;
15071                         }
15072                         ndr->flags = _flags_save_string;
15073                 }
15074                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15075                 {
15076                         uint32_t _flags_save_string = ndr->flags;
15077                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15078                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15079                         if (_ptr_mui_dll) {
15080                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15081                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15082                         } else {
15083                                 r->mui_dll = NULL;
15084                         }
15085                         ndr->flags = _flags_save_string;
15086                 }
15087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15088                 {
15089                         uint32_t _flags_save_string = ndr->flags;
15090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15091                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15092                         if (_ptr_display_name) {
15093                                 NDR_PULL_ALLOC(ndr, r->display_name);
15094                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15095                         } else {
15096                                 r->display_name = NULL;
15097                         }
15098                         ndr->flags = _flags_save_string;
15099                 }
15100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15101         }
15102         if (ndr_flags & NDR_BUFFERS) {
15103                 {
15104                         uint32_t _flags_save_string = ndr->flags;
15105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15106                         if (r->form_name) {
15107                                 uint32_t _relative_save_offset;
15108                                 _relative_save_offset = ndr->offset;
15109                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15110                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15111                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15112                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15113                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15114                                 ndr->offset = _relative_save_offset;
15115                         }
15116                         ndr->flags = _flags_save_string;
15117                 }
15118                 {
15119                         uint32_t _flags_save_string = ndr->flags;
15120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15121                         if (r->keyword) {
15122                                 uint32_t _relative_save_offset;
15123                                 _relative_save_offset = ndr->offset;
15124                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15125                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15126                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15127                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15128                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15129                                 ndr->offset = _relative_save_offset;
15130                         }
15131                         ndr->flags = _flags_save_string;
15132                 }
15133                 {
15134                         uint32_t _flags_save_string = ndr->flags;
15135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15136                         if (r->mui_dll) {
15137                                 uint32_t _relative_save_offset;
15138                                 _relative_save_offset = ndr->offset;
15139                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15140                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15141                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15142                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15143                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15144                                 ndr->offset = _relative_save_offset;
15145                         }
15146                         ndr->flags = _flags_save_string;
15147                 }
15148                 {
15149                         uint32_t _flags_save_string = ndr->flags;
15150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15151                         if (r->display_name) {
15152                                 uint32_t _relative_save_offset;
15153                                 _relative_save_offset = ndr->offset;
15154                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15155                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15156                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15157                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15158                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15159                                 ndr->offset = _relative_save_offset;
15160                         }
15161                         ndr->flags = _flags_save_string;
15162                 }
15163         }
15164         return NDR_ERR_SUCCESS;
15165 }
15166
15167 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15168 {
15169         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15170         ndr->depth++;
15171         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15172         ndr_print_ptr(ndr, "form_name", r->form_name);
15173         ndr->depth++;
15174         if (r->form_name) {
15175                 ndr_print_string(ndr, "form_name", r->form_name);
15176         }
15177         ndr->depth--;
15178         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15179         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15180         ndr_print_ptr(ndr, "keyword", r->keyword);
15181         ndr->depth++;
15182         if (r->keyword) {
15183                 ndr_print_string(ndr, "keyword", r->keyword);
15184         }
15185         ndr->depth--;
15186         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15187         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15188         ndr->depth++;
15189         if (r->mui_dll) {
15190                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15191         }
15192         ndr->depth--;
15193         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15194         ndr_print_ptr(ndr, "display_name", r->display_name);
15195         ndr->depth++;
15196         if (r->display_name) {
15197                 ndr_print_string(ndr, "display_name", r->display_name);
15198         }
15199         ndr->depth--;
15200         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15201         ndr->depth--;
15202 }
15203
15204 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15205 {
15206         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15207 }
15208
15209 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15210 {
15211         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15212         if (ndr_flags & NDR_SCALARS) {
15213                 int level = ndr_push_get_switch_value(ndr, r);
15214                 switch (level) {
15215                         case 1: {
15216                                 NDR_CHECK(ndr_push_align(ndr, 4));
15217                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15218                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15219                         break; }
15220
15221                         case 2: {
15222                                 NDR_CHECK(ndr_push_align(ndr, 4));
15223                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15224                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15225                         break; }
15226
15227                         default: {
15228                         break; }
15229
15230                 }
15231         }
15232         if (ndr_flags & NDR_BUFFERS) {
15233                 int level = ndr_push_get_switch_value(ndr, r);
15234                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15235                 switch (level) {
15236                         case 1:
15237                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15238                         break;
15239
15240                         case 2:
15241                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15242                         break;
15243
15244                         default:
15245                         break;
15246
15247                 }
15248         }
15249         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15250         return NDR_ERR_SUCCESS;
15251 }
15252
15253 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15254 {
15255         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15256         int level;
15257         level = ndr_pull_get_switch_value(ndr, r);
15258         if (ndr_flags & NDR_SCALARS) {
15259                 switch (level) {
15260                         case 1: {
15261                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15262                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15263                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15264                         break; }
15265
15266                         case 2: {
15267                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15268                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15269                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15270                         break; }
15271
15272                         default: {
15273                         break; }
15274
15275                 }
15276         }
15277         if (ndr_flags & NDR_BUFFERS) {
15278                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15279                 switch (level) {
15280                         case 1:
15281                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15282                         break;
15283
15284                         case 2:
15285                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15286                         break;
15287
15288                         default:
15289                         break;
15290
15291                 }
15292         }
15293         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15294         return NDR_ERR_SUCCESS;
15295 }
15296
15297 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15298 {
15299         int level;
15300         level = ndr_print_get_switch_value(ndr, r);
15301         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15302         switch (level) {
15303                 case 1:
15304                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15305                 break;
15306
15307                 case 2:
15308                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15309                 break;
15310
15311                 default:
15312                 break;
15313
15314         }
15315 }
15316
15317 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15318 {
15319         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15320 }
15321
15322 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15323 {
15324         if (ndr_flags & NDR_SCALARS) {
15325                 NDR_CHECK(ndr_push_align(ndr, 4));
15326                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15328                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15329                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15330         }
15331         if (ndr_flags & NDR_BUFFERS) {
15332                 if (r->form_name) {
15333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15336                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15337                 }
15338         }
15339         return NDR_ERR_SUCCESS;
15340 }
15341
15342 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15343 {
15344         uint32_t _ptr_form_name;
15345         TALLOC_CTX *_mem_save_form_name_0;
15346         if (ndr_flags & NDR_SCALARS) {
15347                 NDR_CHECK(ndr_pull_align(ndr, 4));
15348                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15349                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15350                 if (_ptr_form_name) {
15351                         NDR_PULL_ALLOC(ndr, r->form_name);
15352                 } else {
15353                         r->form_name = NULL;
15354                 }
15355                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15356                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15357         }
15358         if (ndr_flags & NDR_BUFFERS) {
15359                 if (r->form_name) {
15360                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15361                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15364                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15365                                 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));
15366                         }
15367                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15368                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15370                 }
15371         }
15372         return NDR_ERR_SUCCESS;
15373 }
15374
15375 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15376 {
15377         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15378         ndr->depth++;
15379         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15380         ndr_print_ptr(ndr, "form_name", r->form_name);
15381         ndr->depth++;
15382         if (r->form_name) {
15383                 ndr_print_string(ndr, "form_name", r->form_name);
15384         }
15385         ndr->depth--;
15386         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15387         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15388         ndr->depth--;
15389 }
15390
15391 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15392 {
15393         if (ndr_flags & NDR_SCALARS) {
15394                 NDR_CHECK(ndr_push_align(ndr, 4));
15395                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15397                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15398                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15400                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15405         }
15406         if (ndr_flags & NDR_BUFFERS) {
15407                 if (r->form_name) {
15408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15411                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15412                 }
15413                 if (r->keyword) {
15414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15416                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15417                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15418                 }
15419                 if (r->mui_dll) {
15420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15421                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15422                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15423                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15424                 }
15425                 if (r->display_name) {
15426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15429                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15430                 }
15431         }
15432         return NDR_ERR_SUCCESS;
15433 }
15434
15435 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15436 {
15437         uint32_t _ptr_form_name;
15438         TALLOC_CTX *_mem_save_form_name_0;
15439         uint32_t _ptr_keyword;
15440         TALLOC_CTX *_mem_save_keyword_0;
15441         uint32_t _ptr_mui_dll;
15442         TALLOC_CTX *_mem_save_mui_dll_0;
15443         uint32_t _ptr_display_name;
15444         TALLOC_CTX *_mem_save_display_name_0;
15445         if (ndr_flags & NDR_SCALARS) {
15446                 NDR_CHECK(ndr_pull_align(ndr, 4));
15447                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15449                 if (_ptr_form_name) {
15450                         NDR_PULL_ALLOC(ndr, r->form_name);
15451                 } else {
15452                         r->form_name = NULL;
15453                 }
15454                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15455                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15457                 if (_ptr_keyword) {
15458                         NDR_PULL_ALLOC(ndr, r->keyword);
15459                 } else {
15460                         r->keyword = NULL;
15461                 }
15462                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15464                 if (_ptr_mui_dll) {
15465                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15466                 } else {
15467                         r->mui_dll = NULL;
15468                 }
15469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15471                 if (_ptr_display_name) {
15472                         NDR_PULL_ALLOC(ndr, r->display_name);
15473                 } else {
15474                         r->display_name = NULL;
15475                 }
15476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15477         }
15478         if (ndr_flags & NDR_BUFFERS) {
15479                 if (r->form_name) {
15480                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15481                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15482                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15483                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15484                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15485                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
15486                         }
15487                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15488                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15490                 }
15491                 if (r->keyword) {
15492                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15493                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15494                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15495                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15496                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15497                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->keyword), ndr_get_array_length(ndr, &r->keyword));
15498                         }
15499                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15500                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15502                 }
15503                 if (r->mui_dll) {
15504                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15505                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15506                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15507                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15508                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15509                                 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));
15510                         }
15511                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15512                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15514                 }
15515                 if (r->display_name) {
15516                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15517                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15518                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15519                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15520                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15521                                 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));
15522                         }
15523                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15524                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15526                 }
15527         }
15528         return NDR_ERR_SUCCESS;
15529 }
15530
15531 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15532 {
15533         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15534         ndr->depth++;
15535         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15536         ndr_print_ptr(ndr, "form_name", r->form_name);
15537         ndr->depth++;
15538         if (r->form_name) {
15539                 ndr_print_string(ndr, "form_name", r->form_name);
15540         }
15541         ndr->depth--;
15542         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15543         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15544         ndr_print_ptr(ndr, "keyword", r->keyword);
15545         ndr->depth++;
15546         if (r->keyword) {
15547                 ndr_print_string(ndr, "keyword", r->keyword);
15548         }
15549         ndr->depth--;
15550         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15551         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15552         ndr->depth++;
15553         if (r->mui_dll) {
15554                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15555         }
15556         ndr->depth--;
15557         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15558         ndr_print_ptr(ndr, "display_name", r->display_name);
15559         ndr->depth++;
15560         if (r->display_name) {
15561                 ndr_print_string(ndr, "display_name", r->display_name);
15562         }
15563         ndr->depth--;
15564         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15565         ndr->depth--;
15566 }
15567
15568 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15569 {
15570         if (ndr_flags & NDR_SCALARS) {
15571                 int level = ndr_push_get_switch_value(ndr, r);
15572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15573                 switch (level) {
15574                         case 1: {
15575                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15576                         break; }
15577
15578                         case 2: {
15579                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15580                         break; }
15581
15582                         default:
15583                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15584                 }
15585         }
15586         if (ndr_flags & NDR_BUFFERS) {
15587                 int level = ndr_push_get_switch_value(ndr, r);
15588                 switch (level) {
15589                         case 1:
15590                                 if (r->info1) {
15591                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15592                                 }
15593                         break;
15594
15595                         case 2:
15596                                 if (r->info2) {
15597                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15598                                 }
15599                         break;
15600
15601                         default:
15602                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15603                 }
15604         }
15605         return NDR_ERR_SUCCESS;
15606 }
15607
15608 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15609 {
15610         int level;
15611         uint32_t _level;
15612         TALLOC_CTX *_mem_save_info1_0;
15613         TALLOC_CTX *_mem_save_info2_0;
15614         level = ndr_pull_get_switch_value(ndr, r);
15615         if (ndr_flags & NDR_SCALARS) {
15616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15617                 if (_level != level) {
15618                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15619                 }
15620                 switch (level) {
15621                         case 1: {
15622                                 uint32_t _ptr_info1;
15623                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15624                                 if (_ptr_info1) {
15625                                         NDR_PULL_ALLOC(ndr, r->info1);
15626                                 } else {
15627                                         r->info1 = NULL;
15628                                 }
15629                         break; }
15630
15631                         case 2: {
15632                                 uint32_t _ptr_info2;
15633                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15634                                 if (_ptr_info2) {
15635                                         NDR_PULL_ALLOC(ndr, r->info2);
15636                                 } else {
15637                                         r->info2 = NULL;
15638                                 }
15639                         break; }
15640
15641                         default:
15642                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15643                 }
15644         }
15645         if (ndr_flags & NDR_BUFFERS) {
15646                 switch (level) {
15647                         case 1:
15648                                 if (r->info1) {
15649                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15650                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15651                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15652                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15653                                 }
15654                         break;
15655
15656                         case 2:
15657                                 if (r->info2) {
15658                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15659                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15660                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15661                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15662                                 }
15663                         break;
15664
15665                         default:
15666                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15667                 }
15668         }
15669         return NDR_ERR_SUCCESS;
15670 }
15671
15672 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15673 {
15674         int level;
15675         level = ndr_print_get_switch_value(ndr, r);
15676         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15677         switch (level) {
15678                 case 1:
15679                         ndr_print_ptr(ndr, "info1", r->info1);
15680                         ndr->depth++;
15681                         if (r->info1) {
15682                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15683                         }
15684                         ndr->depth--;
15685                 break;
15686
15687                 case 2:
15688                         ndr_print_ptr(ndr, "info2", r->info2);
15689                         ndr->depth++;
15690                         if (r->info2) {
15691                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15692                         }
15693                         ndr->depth--;
15694                 break;
15695
15696                 default:
15697                         ndr_print_bad_level(ndr, name, level);
15698         }
15699 }
15700
15701 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15702 {
15703         if (ndr_flags & NDR_SCALARS) {
15704                 NDR_CHECK(ndr_push_align(ndr, 4));
15705                 {
15706                         uint32_t _flags_save_string = ndr->flags;
15707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15708                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15709                         ndr->flags = _flags_save_string;
15710                 }
15711         }
15712         if (ndr_flags & NDR_BUFFERS) {
15713                 {
15714                         uint32_t _flags_save_string = ndr->flags;
15715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15716                         if (r->port_name) {
15717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15718                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15719                         }
15720                         ndr->flags = _flags_save_string;
15721                 }
15722         }
15723         return NDR_ERR_SUCCESS;
15724 }
15725
15726 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15727 {
15728         uint32_t _ptr_port_name;
15729         TALLOC_CTX *_mem_save_port_name_0;
15730         if (ndr_flags & NDR_SCALARS) {
15731                 NDR_CHECK(ndr_pull_align(ndr, 4));
15732                 {
15733                         uint32_t _flags_save_string = ndr->flags;
15734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15735                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15736                         if (_ptr_port_name) {
15737                                 NDR_PULL_ALLOC(ndr, r->port_name);
15738                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15739                         } else {
15740                                 r->port_name = NULL;
15741                         }
15742                         ndr->flags = _flags_save_string;
15743                 }
15744         }
15745         if (ndr_flags & NDR_BUFFERS) {
15746                 {
15747                         uint32_t _flags_save_string = ndr->flags;
15748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15749                         if (r->port_name) {
15750                                 uint32_t _relative_save_offset;
15751                                 _relative_save_offset = ndr->offset;
15752                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15753                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15754                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15755                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15756                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15757                                 ndr->offset = _relative_save_offset;
15758                         }
15759                         ndr->flags = _flags_save_string;
15760                 }
15761         }
15762         return NDR_ERR_SUCCESS;
15763 }
15764
15765 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15766 {
15767         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15768         ndr->depth++;
15769         ndr_print_ptr(ndr, "port_name", r->port_name);
15770         ndr->depth++;
15771         if (r->port_name) {
15772                 ndr_print_string(ndr, "port_name", r->port_name);
15773         }
15774         ndr->depth--;
15775         ndr->depth--;
15776 }
15777
15778 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15779 {
15780         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15781 }
15782
15783 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15784 {
15785         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15786         return NDR_ERR_SUCCESS;
15787 }
15788
15789 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15790 {
15791         uint32_t v;
15792         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15793         *r = v;
15794         return NDR_ERR_SUCCESS;
15795 }
15796
15797 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15798 {
15799         ndr_print_uint32(ndr, name, r);
15800         ndr->depth++;
15801         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15802         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15803         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15804         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15805         ndr->depth--;
15806 }
15807
15808 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15809 {
15810         if (ndr_flags & NDR_SCALARS) {
15811                 NDR_CHECK(ndr_push_align(ndr, 4));
15812                 {
15813                         uint32_t _flags_save_string = ndr->flags;
15814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15815                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15816                         ndr->flags = _flags_save_string;
15817                 }
15818                 {
15819                         uint32_t _flags_save_string = ndr->flags;
15820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15821                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15822                         ndr->flags = _flags_save_string;
15823                 }
15824                 {
15825                         uint32_t _flags_save_string = ndr->flags;
15826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15827                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15828                         ndr->flags = _flags_save_string;
15829                 }
15830                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15832         }
15833         if (ndr_flags & NDR_BUFFERS) {
15834                 {
15835                         uint32_t _flags_save_string = ndr->flags;
15836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15837                         if (r->port_name) {
15838                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15839                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15840                         }
15841                         ndr->flags = _flags_save_string;
15842                 }
15843                 {
15844                         uint32_t _flags_save_string = ndr->flags;
15845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15846                         if (r->monitor_name) {
15847                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15848                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15849                         }
15850                         ndr->flags = _flags_save_string;
15851                 }
15852                 {
15853                         uint32_t _flags_save_string = ndr->flags;
15854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15855                         if (r->description) {
15856                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15858                         }
15859                         ndr->flags = _flags_save_string;
15860                 }
15861         }
15862         return NDR_ERR_SUCCESS;
15863 }
15864
15865 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15866 {
15867         uint32_t _ptr_port_name;
15868         TALLOC_CTX *_mem_save_port_name_0;
15869         uint32_t _ptr_monitor_name;
15870         TALLOC_CTX *_mem_save_monitor_name_0;
15871         uint32_t _ptr_description;
15872         TALLOC_CTX *_mem_save_description_0;
15873         if (ndr_flags & NDR_SCALARS) {
15874                 NDR_CHECK(ndr_pull_align(ndr, 4));
15875                 {
15876                         uint32_t _flags_save_string = ndr->flags;
15877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15878                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15879                         if (_ptr_port_name) {
15880                                 NDR_PULL_ALLOC(ndr, r->port_name);
15881                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15882                         } else {
15883                                 r->port_name = NULL;
15884                         }
15885                         ndr->flags = _flags_save_string;
15886                 }
15887                 {
15888                         uint32_t _flags_save_string = ndr->flags;
15889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15890                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15891                         if (_ptr_monitor_name) {
15892                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15893                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15894                         } else {
15895                                 r->monitor_name = NULL;
15896                         }
15897                         ndr->flags = _flags_save_string;
15898                 }
15899                 {
15900                         uint32_t _flags_save_string = ndr->flags;
15901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15902                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15903                         if (_ptr_description) {
15904                                 NDR_PULL_ALLOC(ndr, r->description);
15905                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15906                         } else {
15907                                 r->description = NULL;
15908                         }
15909                         ndr->flags = _flags_save_string;
15910                 }
15911                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15913         }
15914         if (ndr_flags & NDR_BUFFERS) {
15915                 {
15916                         uint32_t _flags_save_string = ndr->flags;
15917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15918                         if (r->port_name) {
15919                                 uint32_t _relative_save_offset;
15920                                 _relative_save_offset = ndr->offset;
15921                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15922                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15923                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15924                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15925                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15926                                 ndr->offset = _relative_save_offset;
15927                         }
15928                         ndr->flags = _flags_save_string;
15929                 }
15930                 {
15931                         uint32_t _flags_save_string = ndr->flags;
15932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15933                         if (r->monitor_name) {
15934                                 uint32_t _relative_save_offset;
15935                                 _relative_save_offset = ndr->offset;
15936                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15937                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15938                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15939                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15940                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15941                                 ndr->offset = _relative_save_offset;
15942                         }
15943                         ndr->flags = _flags_save_string;
15944                 }
15945                 {
15946                         uint32_t _flags_save_string = ndr->flags;
15947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15948                         if (r->description) {
15949                                 uint32_t _relative_save_offset;
15950                                 _relative_save_offset = ndr->offset;
15951                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15952                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15953                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15954                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15955                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15956                                 ndr->offset = _relative_save_offset;
15957                         }
15958                         ndr->flags = _flags_save_string;
15959                 }
15960         }
15961         return NDR_ERR_SUCCESS;
15962 }
15963
15964 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15965 {
15966         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15967         ndr->depth++;
15968         ndr_print_ptr(ndr, "port_name", r->port_name);
15969         ndr->depth++;
15970         if (r->port_name) {
15971                 ndr_print_string(ndr, "port_name", r->port_name);
15972         }
15973         ndr->depth--;
15974         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15975         ndr->depth++;
15976         if (r->monitor_name) {
15977                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15978         }
15979         ndr->depth--;
15980         ndr_print_ptr(ndr, "description", r->description);
15981         ndr->depth++;
15982         if (r->description) {
15983                 ndr_print_string(ndr, "description", r->description);
15984         }
15985         ndr->depth--;
15986         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15987         ndr_print_uint32(ndr, "reserved", r->reserved);
15988         ndr->depth--;
15989 }
15990
15991 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15992 {
15993         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
15994 }
15995
15996 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
15997 {
15998         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15999         return NDR_ERR_SUCCESS;
16000 }
16001
16002 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16003 {
16004         uint32_t v;
16005         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16006         *r = v;
16007         return NDR_ERR_SUCCESS;
16008 }
16009
16010 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16011 {
16012         const char *val = NULL;
16013
16014         switch (r) {
16015                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16016                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16017                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16018                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16019                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16020                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16021                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16022                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16023                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16024                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16025                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16026                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16027                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16028         }
16029         ndr_print_enum(ndr, name, "ENUM", val, r);
16030 }
16031
16032 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16033 {
16034         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16035         return NDR_ERR_SUCCESS;
16036 }
16037
16038 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16039 {
16040         uint32_t v;
16041         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16042         *r = v;
16043         return NDR_ERR_SUCCESS;
16044 }
16045
16046 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16047 {
16048         const char *val = NULL;
16049
16050         switch (r) {
16051                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16052                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16053                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16054         }
16055         ndr_print_enum(ndr, name, "ENUM", val, r);
16056 }
16057
16058 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16059 {
16060         if (ndr_flags & NDR_SCALARS) {
16061                 NDR_CHECK(ndr_push_align(ndr, 4));
16062                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16063                 {
16064                         uint32_t _flags_save_string = ndr->flags;
16065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16066                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16067                         ndr->flags = _flags_save_string;
16068                 }
16069                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16070         }
16071         if (ndr_flags & NDR_BUFFERS) {
16072                 {
16073                         uint32_t _flags_save_string = ndr->flags;
16074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16075                         if (r->status_string) {
16076                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16077                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16078                         }
16079                         ndr->flags = _flags_save_string;
16080                 }
16081         }
16082         return NDR_ERR_SUCCESS;
16083 }
16084
16085 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16086 {
16087         uint32_t _ptr_status_string;
16088         TALLOC_CTX *_mem_save_status_string_0;
16089         if (ndr_flags & NDR_SCALARS) {
16090                 NDR_CHECK(ndr_pull_align(ndr, 4));
16091                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16092                 {
16093                         uint32_t _flags_save_string = ndr->flags;
16094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16095                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16096                         if (_ptr_status_string) {
16097                                 NDR_PULL_ALLOC(ndr, r->status_string);
16098                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16099                         } else {
16100                                 r->status_string = NULL;
16101                         }
16102                         ndr->flags = _flags_save_string;
16103                 }
16104                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16105         }
16106         if (ndr_flags & NDR_BUFFERS) {
16107                 {
16108                         uint32_t _flags_save_string = ndr->flags;
16109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16110                         if (r->status_string) {
16111                                 uint32_t _relative_save_offset;
16112                                 _relative_save_offset = ndr->offset;
16113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16114                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16115                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16116                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16118                                 ndr->offset = _relative_save_offset;
16119                         }
16120                         ndr->flags = _flags_save_string;
16121                 }
16122         }
16123         return NDR_ERR_SUCCESS;
16124 }
16125
16126 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16127 {
16128         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16129         ndr->depth++;
16130         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16131         ndr_print_ptr(ndr, "status_string", r->status_string);
16132         ndr->depth++;
16133         if (r->status_string) {
16134                 ndr_print_string(ndr, "status_string", r->status_string);
16135         }
16136         ndr->depth--;
16137         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16138         ndr->depth--;
16139 }
16140
16141 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16142 {
16143         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16144 }
16145
16146 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16147 {
16148         if (ndr_flags & NDR_SCALARS) {
16149                 NDR_CHECK(ndr_push_align(ndr, 4));
16150                 {
16151                         uint32_t _flags_save_string = ndr->flags;
16152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16153                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16154                         ndr->flags = _flags_save_string;
16155                 }
16156                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16157         }
16158         if (ndr_flags & NDR_BUFFERS) {
16159                 {
16160                         uint32_t _flags_save_string = ndr->flags;
16161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16162                         if (r->port_name) {
16163                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16165                         }
16166                         ndr->flags = _flags_save_string;
16167                 }
16168         }
16169         return NDR_ERR_SUCCESS;
16170 }
16171
16172 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16173 {
16174         uint32_t _ptr_port_name;
16175         TALLOC_CTX *_mem_save_port_name_0;
16176         if (ndr_flags & NDR_SCALARS) {
16177                 NDR_CHECK(ndr_pull_align(ndr, 4));
16178                 {
16179                         uint32_t _flags_save_string = ndr->flags;
16180                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16181                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16182                         if (_ptr_port_name) {
16183                                 NDR_PULL_ALLOC(ndr, r->port_name);
16184                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16185                         } else {
16186                                 r->port_name = NULL;
16187                         }
16188                         ndr->flags = _flags_save_string;
16189                 }
16190                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16191         }
16192         if (ndr_flags & NDR_BUFFERS) {
16193                 {
16194                         uint32_t _flags_save_string = ndr->flags;
16195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16196                         if (r->port_name) {
16197                                 uint32_t _relative_save_offset;
16198                                 _relative_save_offset = ndr->offset;
16199                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16200                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16201                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16202                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16203                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16204                                 ndr->offset = _relative_save_offset;
16205                         }
16206                         ndr->flags = _flags_save_string;
16207                 }
16208         }
16209         return NDR_ERR_SUCCESS;
16210 }
16211
16212 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16213 {
16214         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16215         ndr->depth++;
16216         ndr_print_ptr(ndr, "port_name", r->port_name);
16217         ndr->depth++;
16218         if (r->port_name) {
16219                 ndr_print_string(ndr, "port_name", r->port_name);
16220         }
16221         ndr->depth--;
16222         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16223         ndr->depth--;
16224 }
16225
16226 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16227 {
16228         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16229 }
16230
16231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16232 {
16233         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16234         if (ndr_flags & NDR_SCALARS) {
16235                 int level = ndr_push_get_switch_value(ndr, r);
16236                 switch (level) {
16237                         case 1: {
16238                                 NDR_CHECK(ndr_push_align(ndr, 4));
16239                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16240                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16241                         break; }
16242
16243                         case 2: {
16244                                 NDR_CHECK(ndr_push_align(ndr, 4));
16245                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16246                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16247                         break; }
16248
16249                         case 3: {
16250                                 NDR_CHECK(ndr_push_align(ndr, 4));
16251                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16252                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16253                         break; }
16254
16255                         case 0xff: {
16256                                 NDR_CHECK(ndr_push_align(ndr, 4));
16257                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16258                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16259                         break; }
16260
16261                         default: {
16262                         break; }
16263
16264                 }
16265         }
16266         if (ndr_flags & NDR_BUFFERS) {
16267                 int level = ndr_push_get_switch_value(ndr, r);
16268                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16269                 switch (level) {
16270                         case 1:
16271                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16272                         break;
16273
16274                         case 2:
16275                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16276                         break;
16277
16278                         case 3:
16279                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16280                         break;
16281
16282                         case 0xff:
16283                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16284                         break;
16285
16286                         default:
16287                         break;
16288
16289                 }
16290         }
16291         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16292         return NDR_ERR_SUCCESS;
16293 }
16294
16295 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16296 {
16297         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16298         int level;
16299         level = ndr_pull_get_switch_value(ndr, r);
16300         if (ndr_flags & NDR_SCALARS) {
16301                 switch (level) {
16302                         case 1: {
16303                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16304                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16305                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16306                         break; }
16307
16308                         case 2: {
16309                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16310                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16311                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16312                         break; }
16313
16314                         case 3: {
16315                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16316                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16317                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16318                         break; }
16319
16320                         case 0xff: {
16321                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16322                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16323                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16324                         break; }
16325
16326                         default: {
16327                         break; }
16328
16329                 }
16330         }
16331         if (ndr_flags & NDR_BUFFERS) {
16332                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16333                 switch (level) {
16334                         case 1:
16335                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16336                         break;
16337
16338                         case 2:
16339                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16340                         break;
16341
16342                         case 3:
16343                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16344                         break;
16345
16346                         case 0xff:
16347                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16348                         break;
16349
16350                         default:
16351                         break;
16352
16353                 }
16354         }
16355         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16356         return NDR_ERR_SUCCESS;
16357 }
16358
16359 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16360 {
16361         int level;
16362         level = ndr_print_get_switch_value(ndr, r);
16363         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16364         switch (level) {
16365                 case 1:
16366                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16367                 break;
16368
16369                 case 2:
16370                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16371                 break;
16372
16373                 case 3:
16374                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16375                 break;
16376
16377                 case 0xff:
16378                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16379                 break;
16380
16381                 default:
16382                 break;
16383
16384         }
16385 }
16386
16387 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16388 {
16389         if (ndr_flags & NDR_SCALARS) {
16390                 NDR_CHECK(ndr_push_align(ndr, 4));
16391                 {
16392                         uint32_t _flags_save_string = ndr->flags;
16393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16394                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16395                         ndr->flags = _flags_save_string;
16396                 }
16397         }
16398         if (ndr_flags & NDR_BUFFERS) {
16399                 {
16400                         uint32_t _flags_save_string = ndr->flags;
16401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16402                         if (r->monitor_name) {
16403                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16404                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16405                         }
16406                         ndr->flags = _flags_save_string;
16407                 }
16408         }
16409         return NDR_ERR_SUCCESS;
16410 }
16411
16412 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16413 {
16414         uint32_t _ptr_monitor_name;
16415         TALLOC_CTX *_mem_save_monitor_name_0;
16416         if (ndr_flags & NDR_SCALARS) {
16417                 NDR_CHECK(ndr_pull_align(ndr, 4));
16418                 {
16419                         uint32_t _flags_save_string = ndr->flags;
16420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16421                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16422                         if (_ptr_monitor_name) {
16423                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16424                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16425                         } else {
16426                                 r->monitor_name = NULL;
16427                         }
16428                         ndr->flags = _flags_save_string;
16429                 }
16430         }
16431         if (ndr_flags & NDR_BUFFERS) {
16432                 {
16433                         uint32_t _flags_save_string = ndr->flags;
16434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16435                         if (r->monitor_name) {
16436                                 uint32_t _relative_save_offset;
16437                                 _relative_save_offset = ndr->offset;
16438                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16439                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16440                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16441                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16442                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16443                                 ndr->offset = _relative_save_offset;
16444                         }
16445                         ndr->flags = _flags_save_string;
16446                 }
16447         }
16448         return NDR_ERR_SUCCESS;
16449 }
16450
16451 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16452 {
16453         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16454         ndr->depth++;
16455         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16456         ndr->depth++;
16457         if (r->monitor_name) {
16458                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16459         }
16460         ndr->depth--;
16461         ndr->depth--;
16462 }
16463
16464 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16465 {
16466         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16467 }
16468
16469 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16470 {
16471         if (ndr_flags & NDR_SCALARS) {
16472                 NDR_CHECK(ndr_push_align(ndr, 4));
16473                 {
16474                         uint32_t _flags_save_string = ndr->flags;
16475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16476                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16477                         ndr->flags = _flags_save_string;
16478                 }
16479                 {
16480                         uint32_t _flags_save_string = ndr->flags;
16481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16482                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16483                         ndr->flags = _flags_save_string;
16484                 }
16485                 {
16486                         uint32_t _flags_save_string = ndr->flags;
16487                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16488                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16489                         ndr->flags = _flags_save_string;
16490                 }
16491         }
16492         if (ndr_flags & NDR_BUFFERS) {
16493                 {
16494                         uint32_t _flags_save_string = ndr->flags;
16495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16496                         if (r->monitor_name) {
16497                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16498                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16499                         }
16500                         ndr->flags = _flags_save_string;
16501                 }
16502                 {
16503                         uint32_t _flags_save_string = ndr->flags;
16504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16505                         if (r->environment) {
16506                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16507                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16508                         }
16509                         ndr->flags = _flags_save_string;
16510                 }
16511                 {
16512                         uint32_t _flags_save_string = ndr->flags;
16513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16514                         if (r->dll_name) {
16515                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16516                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16517                         }
16518                         ndr->flags = _flags_save_string;
16519                 }
16520         }
16521         return NDR_ERR_SUCCESS;
16522 }
16523
16524 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16525 {
16526         uint32_t _ptr_monitor_name;
16527         TALLOC_CTX *_mem_save_monitor_name_0;
16528         uint32_t _ptr_environment;
16529         TALLOC_CTX *_mem_save_environment_0;
16530         uint32_t _ptr_dll_name;
16531         TALLOC_CTX *_mem_save_dll_name_0;
16532         if (ndr_flags & NDR_SCALARS) {
16533                 NDR_CHECK(ndr_pull_align(ndr, 4));
16534                 {
16535                         uint32_t _flags_save_string = ndr->flags;
16536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16537                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16538                         if (_ptr_monitor_name) {
16539                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16541                         } else {
16542                                 r->monitor_name = NULL;
16543                         }
16544                         ndr->flags = _flags_save_string;
16545                 }
16546                 {
16547                         uint32_t _flags_save_string = ndr->flags;
16548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16550                         if (_ptr_environment) {
16551                                 NDR_PULL_ALLOC(ndr, r->environment);
16552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16553                         } else {
16554                                 r->environment = NULL;
16555                         }
16556                         ndr->flags = _flags_save_string;
16557                 }
16558                 {
16559                         uint32_t _flags_save_string = ndr->flags;
16560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16561                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16562                         if (_ptr_dll_name) {
16563                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16564                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16565                         } else {
16566                                 r->dll_name = NULL;
16567                         }
16568                         ndr->flags = _flags_save_string;
16569                 }
16570         }
16571         if (ndr_flags & NDR_BUFFERS) {
16572                 {
16573                         uint32_t _flags_save_string = ndr->flags;
16574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16575                         if (r->monitor_name) {
16576                                 uint32_t _relative_save_offset;
16577                                 _relative_save_offset = ndr->offset;
16578                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16579                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16580                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16581                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16582                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16583                                 ndr->offset = _relative_save_offset;
16584                         }
16585                         ndr->flags = _flags_save_string;
16586                 }
16587                 {
16588                         uint32_t _flags_save_string = ndr->flags;
16589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16590                         if (r->environment) {
16591                                 uint32_t _relative_save_offset;
16592                                 _relative_save_offset = ndr->offset;
16593                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16594                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16595                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16596                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16597                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16598                                 ndr->offset = _relative_save_offset;
16599                         }
16600                         ndr->flags = _flags_save_string;
16601                 }
16602                 {
16603                         uint32_t _flags_save_string = ndr->flags;
16604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16605                         if (r->dll_name) {
16606                                 uint32_t _relative_save_offset;
16607                                 _relative_save_offset = ndr->offset;
16608                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16609                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16610                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16613                                 ndr->offset = _relative_save_offset;
16614                         }
16615                         ndr->flags = _flags_save_string;
16616                 }
16617         }
16618         return NDR_ERR_SUCCESS;
16619 }
16620
16621 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16622 {
16623         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16624         ndr->depth++;
16625         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16626         ndr->depth++;
16627         if (r->monitor_name) {
16628                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16629         }
16630         ndr->depth--;
16631         ndr_print_ptr(ndr, "environment", r->environment);
16632         ndr->depth++;
16633         if (r->environment) {
16634                 ndr_print_string(ndr, "environment", r->environment);
16635         }
16636         ndr->depth--;
16637         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16638         ndr->depth++;
16639         if (r->dll_name) {
16640                 ndr_print_string(ndr, "dll_name", r->dll_name);
16641         }
16642         ndr->depth--;
16643         ndr->depth--;
16644 }
16645
16646 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16647 {
16648         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16649 }
16650
16651 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16652 {
16653         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16654         if (ndr_flags & NDR_SCALARS) {
16655                 int level = ndr_push_get_switch_value(ndr, r);
16656                 switch (level) {
16657                         case 1: {
16658                                 NDR_CHECK(ndr_push_align(ndr, 4));
16659                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16660                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16661                         break; }
16662
16663                         case 2: {
16664                                 NDR_CHECK(ndr_push_align(ndr, 4));
16665                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16666                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16667                         break; }
16668
16669                         default: {
16670                         break; }
16671
16672                 }
16673         }
16674         if (ndr_flags & NDR_BUFFERS) {
16675                 int level = ndr_push_get_switch_value(ndr, r);
16676                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16677                 switch (level) {
16678                         case 1:
16679                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16680                         break;
16681
16682                         case 2:
16683                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16684                         break;
16685
16686                         default:
16687                         break;
16688
16689                 }
16690         }
16691         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16692         return NDR_ERR_SUCCESS;
16693 }
16694
16695 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16696 {
16697         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16698         int level;
16699         level = ndr_pull_get_switch_value(ndr, r);
16700         if (ndr_flags & NDR_SCALARS) {
16701                 switch (level) {
16702                         case 1: {
16703                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16704                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16705                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16706                         break; }
16707
16708                         case 2: {
16709                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16710                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16711                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16712                         break; }
16713
16714                         default: {
16715                         break; }
16716
16717                 }
16718         }
16719         if (ndr_flags & NDR_BUFFERS) {
16720                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16721                 switch (level) {
16722                         case 1:
16723                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16724                         break;
16725
16726                         case 2:
16727                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16728                         break;
16729
16730                         default:
16731                         break;
16732
16733                 }
16734         }
16735         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16736         return NDR_ERR_SUCCESS;
16737 }
16738
16739 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16740 {
16741         int level;
16742         level = ndr_print_get_switch_value(ndr, r);
16743         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16744         switch (level) {
16745                 case 1:
16746                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16747                 break;
16748
16749                 case 2:
16750                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16751                 break;
16752
16753                 default:
16754                 break;
16755
16756         }
16757 }
16758
16759 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16760 {
16761         if (ndr_flags & NDR_SCALARS) {
16762                 NDR_CHECK(ndr_push_align(ndr, 4));
16763                 {
16764                         uint32_t _flags_save_string = ndr->flags;
16765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16766                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16767                         ndr->flags = _flags_save_string;
16768                 }
16769         }
16770         if (ndr_flags & NDR_BUFFERS) {
16771                 {
16772                         uint32_t _flags_save_string = ndr->flags;
16773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16774                         if (r->name_array) {
16775                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16776                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16777                         }
16778                         ndr->flags = _flags_save_string;
16779                 }
16780         }
16781         return NDR_ERR_SUCCESS;
16782 }
16783
16784 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16785 {
16786         uint32_t _ptr_name_array;
16787         TALLOC_CTX *_mem_save_name_array_0;
16788         if (ndr_flags & NDR_SCALARS) {
16789                 NDR_CHECK(ndr_pull_align(ndr, 4));
16790                 {
16791                         uint32_t _flags_save_string = ndr->flags;
16792                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16793                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16794                         if (_ptr_name_array) {
16795                                 NDR_PULL_ALLOC(ndr, r->name_array);
16796                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16797                         } else {
16798                                 r->name_array = NULL;
16799                         }
16800                         ndr->flags = _flags_save_string;
16801                 }
16802         }
16803         if (ndr_flags & NDR_BUFFERS) {
16804                 {
16805                         uint32_t _flags_save_string = ndr->flags;
16806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16807                         if (r->name_array) {
16808                                 uint32_t _relative_save_offset;
16809                                 _relative_save_offset = ndr->offset;
16810                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16811                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16812                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16813                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16814                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16815                                 ndr->offset = _relative_save_offset;
16816                         }
16817                         ndr->flags = _flags_save_string;
16818                 }
16819         }
16820         return NDR_ERR_SUCCESS;
16821 }
16822
16823 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16824 {
16825         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16826         ndr->depth++;
16827         ndr_print_ptr(ndr, "name_array", r->name_array);
16828         ndr->depth++;
16829         if (r->name_array) {
16830                 ndr_print_string(ndr, "name_array", r->name_array);
16831         }
16832         ndr->depth--;
16833         ndr->depth--;
16834 }
16835
16836 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16837 {
16838         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16839 }
16840
16841 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16842 {
16843         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16844         if (ndr_flags & NDR_SCALARS) {
16845                 int level = ndr_push_get_switch_value(ndr, r);
16846                 switch (level) {
16847                         case 1: {
16848                                 NDR_CHECK(ndr_push_align(ndr, 4));
16849                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16850                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16851                         break; }
16852
16853                         default: {
16854                         break; }
16855
16856                 }
16857         }
16858         if (ndr_flags & NDR_BUFFERS) {
16859                 int level = ndr_push_get_switch_value(ndr, r);
16860                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16861                 switch (level) {
16862                         case 1:
16863                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16864                         break;
16865
16866                         default:
16867                         break;
16868
16869                 }
16870         }
16871         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16872         return NDR_ERR_SUCCESS;
16873 }
16874
16875 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16876 {
16877         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16878         int level;
16879         level = ndr_pull_get_switch_value(ndr, r);
16880         if (ndr_flags & NDR_SCALARS) {
16881                 switch (level) {
16882                         case 1: {
16883                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16884                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16885                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16886                         break; }
16887
16888                         default: {
16889                         break; }
16890
16891                 }
16892         }
16893         if (ndr_flags & NDR_BUFFERS) {
16894                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16895                 switch (level) {
16896                         case 1:
16897                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16898                         break;
16899
16900                         default:
16901                         break;
16902
16903                 }
16904         }
16905         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16906         return NDR_ERR_SUCCESS;
16907 }
16908
16909 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16910 {
16911         int level;
16912         level = ndr_print_get_switch_value(ndr, r);
16913         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16914         switch (level) {
16915                 case 1:
16916                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16917                 break;
16918
16919                 default:
16920                 break;
16921
16922         }
16923 }
16924
16925 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16926 {
16927         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16928         return NDR_ERR_SUCCESS;
16929 }
16930
16931 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16932 {
16933         uint32_t v;
16934         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16935         *r = v;
16936         return NDR_ERR_SUCCESS;
16937 }
16938
16939 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16940 {
16941         ndr_print_uint32(ndr, name, r);
16942         ndr->depth++;
16943         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16944         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16945         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16946         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16947         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16950         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16951         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16952         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16953         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16954         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16955         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16956         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16957         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16958         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16964         ndr->depth--;
16965 }
16966
16967 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16968 {
16969         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16970         return NDR_ERR_SUCCESS;
16971 }
16972
16973 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
16974 {
16975         uint16_t v;
16976         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16977         *r = v;
16978         return NDR_ERR_SUCCESS;
16979 }
16980
16981 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16982 {
16983         const char *val = NULL;
16984
16985         switch (r) {
16986                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16987                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16988                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16989                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16990                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16991                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16992                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16993                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16994                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16995                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
16996                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
16997                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
16998                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
16999                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
17000                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
17001                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
17002                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
17003                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
17004                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
17005                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
17006                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
17007                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
17008                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
17009                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
17010                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
17011                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
17012         }
17013         ndr_print_enum(ndr, name, "ENUM", val, r);
17014 }
17015
17016 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17017 {
17018         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17019         return NDR_ERR_SUCCESS;
17020 }
17021
17022 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17023 {
17024         uint16_t v;
17025         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17026         *r = v;
17027         return NDR_ERR_SUCCESS;
17028 }
17029
17030 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17031 {
17032         const char *val = NULL;
17033
17034         switch (r) {
17035                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17036                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17037         }
17038         ndr_print_enum(ndr, name, "ENUM", val, r);
17039 }
17040
17041 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17042 {
17043         uint32_t cntr_fields_1;
17044         if (ndr_flags & NDR_SCALARS) {
17045                 NDR_CHECK(ndr_push_align(ndr, 4));
17046                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17047                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17051                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17052         }
17053         if (ndr_flags & NDR_BUFFERS) {
17054                 if (r->fields) {
17055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17056                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17057                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
17058                         }
17059                 }
17060         }
17061         return NDR_ERR_SUCCESS;
17062 }
17063
17064 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17065 {
17066         uint32_t _ptr_fields;
17067         uint32_t cntr_fields_1;
17068         TALLOC_CTX *_mem_save_fields_0;
17069         TALLOC_CTX *_mem_save_fields_1;
17070         if (ndr_flags & NDR_SCALARS) {
17071                 NDR_CHECK(ndr_pull_align(ndr, 4));
17072                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17073                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17075                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17078                 if (_ptr_fields) {
17079                         NDR_PULL_ALLOC(ndr, r->fields);
17080                 } else {
17081                         r->fields = NULL;
17082                 }
17083         }
17084         if (ndr_flags & NDR_BUFFERS) {
17085                 if (r->fields) {
17086                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17087                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17089                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17090                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17091                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17092                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17093                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17094                         }
17095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17097                 }
17098                 if (r->fields) {
17099                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17100                 }
17101         }
17102         return NDR_ERR_SUCCESS;
17103 }
17104
17105 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17106 {
17107         uint32_t cntr_fields_1;
17108         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17109         ndr->depth++;
17110         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17111         ndr_print_uint16(ndr, "u1", r->u1);
17112         ndr_print_uint32(ndr, "u2", r->u2);
17113         ndr_print_uint32(ndr, "u3", r->u3);
17114         ndr_print_uint32(ndr, "count", r->count);
17115         ndr_print_ptr(ndr, "fields", r->fields);
17116         ndr->depth++;
17117         if (r->fields) {
17118                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17119                 ndr->depth++;
17120                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17121                         char *idx_1=NULL;
17122                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17123                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
17124                                 free(idx_1);
17125                         }
17126                 }
17127                 ndr->depth--;
17128         }
17129         ndr->depth--;
17130         ndr->depth--;
17131 }
17132
17133 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17134 {
17135         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17136         return NDR_ERR_SUCCESS;
17137 }
17138
17139 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17140 {
17141         uint32_t v;
17142         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17143         *r = v;
17144         return NDR_ERR_SUCCESS;
17145 }
17146
17147 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17148 {
17149         ndr_print_uint32(ndr, name, r);
17150         ndr->depth++;
17151         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17152         ndr->depth--;
17153 }
17154
17155 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17156 {
17157         uint32_t cntr_types_1;
17158         if (ndr_flags & NDR_SCALARS) {
17159                 NDR_CHECK(ndr_push_align(ndr, 4));
17160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17161                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17164         }
17165         if (ndr_flags & NDR_BUFFERS) {
17166                 if (r->types) {
17167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17168                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17169                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17170                         }
17171                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17172                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17173                         }
17174                 }
17175         }
17176         return NDR_ERR_SUCCESS;
17177 }
17178
17179 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17180 {
17181         uint32_t _ptr_types;
17182         uint32_t cntr_types_1;
17183         TALLOC_CTX *_mem_save_types_0;
17184         TALLOC_CTX *_mem_save_types_1;
17185         if (ndr_flags & NDR_SCALARS) {
17186                 NDR_CHECK(ndr_pull_align(ndr, 4));
17187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17188                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17190                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17191                 if (_ptr_types) {
17192                         NDR_PULL_ALLOC(ndr, r->types);
17193                 } else {
17194                         r->types = NULL;
17195                 }
17196         }
17197         if (ndr_flags & NDR_BUFFERS) {
17198                 if (r->types) {
17199                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17200                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17202                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17203                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17204                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17205                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17206                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17207                         }
17208                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17209                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17210                         }
17211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17213                 }
17214                 if (r->types) {
17215                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17216                 }
17217         }
17218         return NDR_ERR_SUCCESS;
17219 }
17220
17221 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17222 {
17223         uint32_t cntr_types_1;
17224         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17225         ndr->depth++;
17226         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17227         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17228         ndr_print_uint32(ndr, "count", r->count);
17229         ndr_print_ptr(ndr, "types", r->types);
17230         ndr->depth++;
17231         if (r->types) {
17232                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17233                 ndr->depth++;
17234                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17235                         char *idx_1=NULL;
17236                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17237                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17238                                 free(idx_1);
17239                         }
17240                 }
17241                 ndr->depth--;
17242         }
17243         ndr->depth--;
17244         ndr->depth--;
17245 }
17246
17247 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17248 {
17249         if (ndr_flags & NDR_SCALARS) {
17250                 NDR_CHECK(ndr_push_align(ndr, 4));
17251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17253         }
17254         if (ndr_flags & NDR_BUFFERS) {
17255                 if (r->string) {
17256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17257                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17258                 }
17259         }
17260         return NDR_ERR_SUCCESS;
17261 }
17262
17263 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17264 {
17265         uint32_t _ptr_string;
17266         TALLOC_CTX *_mem_save_string_0;
17267         if (ndr_flags & NDR_SCALARS) {
17268                 NDR_CHECK(ndr_pull_align(ndr, 4));
17269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17271                 if (_ptr_string) {
17272                         NDR_PULL_ALLOC(ndr, r->string);
17273                 } else {
17274                         r->string = NULL;
17275                 }
17276         }
17277         if (ndr_flags & NDR_BUFFERS) {
17278                 if (r->string) {
17279                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17280                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17282                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17284                 }
17285                 if (r->string) {
17286                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17287                 }
17288         }
17289         return NDR_ERR_SUCCESS;
17290 }
17291
17292 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17293 {
17294         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17295         ndr->depth++;
17296         ndr_print_uint32(ndr, "size", r->size);
17297         ndr_print_ptr(ndr, "string", r->string);
17298         ndr->depth++;
17299         if (r->string) {
17300                 ndr_print_string(ndr, "string", r->string);
17301         }
17302         ndr->depth--;
17303         ndr->depth--;
17304 }
17305
17306 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17307 {
17308         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17309         return NDR_ERR_SUCCESS;
17310 }
17311
17312 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17313 {
17314         uint32_t v;
17315         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17316         *r = v;
17317         return NDR_ERR_SUCCESS;
17318 }
17319
17320 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17321 {
17322         const char *val = NULL;
17323
17324         switch (r) {
17325                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17326                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17327                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17328                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17329                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17330         }
17331         ndr_print_enum(ndr, name, "ENUM", val, r);
17332 }
17333
17334 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17335 {
17336         if (ndr_flags & NDR_SCALARS) {
17337                 int level = ndr_push_get_switch_value(ndr, r);
17338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17339                 switch (level) {
17340                         case 1: {
17341                                 uint32_t cntr_integer_0;
17342                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17343                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17344                                 }
17345                         break; }
17346
17347                         case 2: {
17348                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17349                         break; }
17350
17351                         case 3: {
17352                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17353                         break; }
17354
17355                         case 4: {
17356                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17357                         break; }
17358
17359                         case 5: {
17360                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17361                         break; }
17362
17363                         default:
17364                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17365                 }
17366         }
17367         if (ndr_flags & NDR_BUFFERS) {
17368                 int level = ndr_push_get_switch_value(ndr, r);
17369                 switch (level) {
17370                         case 1:
17371                         break;
17372
17373                         case 2:
17374                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17375                         break;
17376
17377                         case 3:
17378                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17379                         break;
17380
17381                         case 4:
17382                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17383                         break;
17384
17385                         case 5:
17386                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17387                         break;
17388
17389                         default:
17390                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17391                 }
17392         }
17393         return NDR_ERR_SUCCESS;
17394 }
17395
17396 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17397 {
17398         int level;
17399         uint32_t _level;
17400         level = ndr_pull_get_switch_value(ndr, r);
17401         if (ndr_flags & NDR_SCALARS) {
17402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17403                 if (_level != level) {
17404                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17405                 }
17406                 switch (level) {
17407                         case 1: {
17408                                 uint32_t cntr_integer_0;
17409                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17410                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17411                                 }
17412                         break; }
17413
17414                         case 2: {
17415                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17416                         break; }
17417
17418                         case 3: {
17419                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17420                         break; }
17421
17422                         case 4: {
17423                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17424                         break; }
17425
17426                         case 5: {
17427                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17428                         break; }
17429
17430                         default:
17431                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17432                 }
17433         }
17434         if (ndr_flags & NDR_BUFFERS) {
17435                 switch (level) {
17436                         case 1:
17437                         break;
17438
17439                         case 2:
17440                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17441                         break;
17442
17443                         case 3:
17444                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17445                         break;
17446
17447                         case 4:
17448                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17449                         break;
17450
17451                         case 5:
17452                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17453                         break;
17454
17455                         default:
17456                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17457                 }
17458         }
17459         return NDR_ERR_SUCCESS;
17460 }
17461
17462 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17463 {
17464         int level;
17465         uint32_t cntr_integer_0;
17466         level = ndr_print_get_switch_value(ndr, r);
17467         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17468         switch (level) {
17469                 case 1:
17470                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17471                         ndr->depth++;
17472                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17473                                 char *idx_0=NULL;
17474                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17475                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17476                                         free(idx_0);
17477                                 }
17478                         }
17479                         ndr->depth--;
17480                 break;
17481
17482                 case 2:
17483                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17484                 break;
17485
17486                 case 3:
17487                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17488                 break;
17489
17490                 case 4:
17491                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17492                 break;
17493
17494                 case 5:
17495                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17496                 break;
17497
17498                 default:
17499                         ndr_print_bad_level(ndr, name, level);
17500         }
17501 }
17502
17503 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17504 {
17505         if (ndr_flags & NDR_SCALARS) {
17506                 NDR_CHECK(ndr_push_align(ndr, 4));
17507                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17508                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17509                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17511                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17512                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17513         }
17514         if (ndr_flags & NDR_BUFFERS) {
17515                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17516         }
17517         return NDR_ERR_SUCCESS;
17518 }
17519
17520 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17521 {
17522         if (ndr_flags & NDR_SCALARS) {
17523                 NDR_CHECK(ndr_pull_align(ndr, 4));
17524                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17525                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17526                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17528                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17529                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17530         }
17531         if (ndr_flags & NDR_BUFFERS) {
17532                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17533         }
17534         return NDR_ERR_SUCCESS;
17535 }
17536
17537 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17538 {
17539         ndr_print_struct(ndr, name, "spoolss_Notify");
17540         ndr->depth++;
17541         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17542         ndr_print_spoolss_Field(ndr, "field", r->field);
17543         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17544         ndr_print_uint32(ndr, "job_id", r->job_id);
17545         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17546         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17547         ndr->depth--;
17548 }
17549
17550 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17551 {
17552         uint32_t cntr_notifies_0;
17553         if (ndr_flags & NDR_SCALARS) {
17554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17555                 NDR_CHECK(ndr_push_align(ndr, 4));
17556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17559                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17560                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17561                 }
17562         }
17563         if (ndr_flags & NDR_BUFFERS) {
17564                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17565                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17566                 }
17567         }
17568         return NDR_ERR_SUCCESS;
17569 }
17570
17571 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17572 {
17573         uint32_t cntr_notifies_0;
17574         TALLOC_CTX *_mem_save_notifies_0;
17575         if (ndr_flags & NDR_SCALARS) {
17576                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17577                 NDR_CHECK(ndr_pull_align(ndr, 4));
17578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17581                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17582                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17583                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17584                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17585                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17586                 }
17587                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17588                 if (r->notifies) {
17589                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17590                 }
17591         }
17592         if (ndr_flags & NDR_BUFFERS) {
17593                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17594                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17595                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17596                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17597                 }
17598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17599         }
17600         return NDR_ERR_SUCCESS;
17601 }
17602
17603 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17604 {
17605         uint32_t cntr_notifies_0;
17606         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17607         ndr->depth++;
17608         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17609         ndr_print_uint32(ndr, "flags", r->flags);
17610         ndr_print_uint32(ndr, "count", r->count);
17611         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17612         ndr->depth++;
17613         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17614                 char *idx_0=NULL;
17615                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17616                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17617                         free(idx_0);
17618                 }
17619         }
17620         ndr->depth--;
17621         ndr->depth--;
17622 }
17623
17624 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17625 {
17626         if (ndr_flags & NDR_SCALARS) {
17627                 int level = ndr_push_get_switch_value(ndr, r);
17628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17629                 switch (level) {
17630                         case 0: {
17631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17632                         break; }
17633
17634                         default:
17635                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17636                 }
17637         }
17638         if (ndr_flags & NDR_BUFFERS) {
17639                 int level = ndr_push_get_switch_value(ndr, r);
17640                 switch (level) {
17641                         case 0:
17642                                 if (r->info0) {
17643                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17644                                 }
17645                         break;
17646
17647                         default:
17648                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17649                 }
17650         }
17651         return NDR_ERR_SUCCESS;
17652 }
17653
17654 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17655 {
17656         int level;
17657         uint32_t _level;
17658         TALLOC_CTX *_mem_save_info0_0;
17659         level = ndr_pull_get_switch_value(ndr, r);
17660         if (ndr_flags & NDR_SCALARS) {
17661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17662                 if (_level != level) {
17663                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17664                 }
17665                 switch (level) {
17666                         case 0: {
17667                                 uint32_t _ptr_info0;
17668                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17669                                 if (_ptr_info0) {
17670                                         NDR_PULL_ALLOC(ndr, r->info0);
17671                                 } else {
17672                                         r->info0 = NULL;
17673                                 }
17674                         break; }
17675
17676                         default:
17677                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17678                 }
17679         }
17680         if (ndr_flags & NDR_BUFFERS) {
17681                 switch (level) {
17682                         case 0:
17683                                 if (r->info0) {
17684                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17685                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17686                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17687                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17688                                 }
17689                         break;
17690
17691                         default:
17692                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17693                 }
17694         }
17695         return NDR_ERR_SUCCESS;
17696 }
17697
17698 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17699 {
17700         int level;
17701         level = ndr_print_get_switch_value(ndr, r);
17702         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17703         switch (level) {
17704                 case 0:
17705                         ndr_print_ptr(ndr, "info0", r->info0);
17706                         ndr->depth++;
17707                         if (r->info0) {
17708                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17709                         }
17710                         ndr->depth--;
17711                 break;
17712
17713                 default:
17714                         ndr_print_bad_level(ndr, name, level);
17715         }
17716 }
17717
17718 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17719 {
17720         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17721         return NDR_ERR_SUCCESS;
17722 }
17723
17724 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17725 {
17726         uint32_t v;
17727         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17728         *r = v;
17729         return NDR_ERR_SUCCESS;
17730 }
17731
17732 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17733 {
17734         ndr_print_uint32(ndr, name, r);
17735         ndr->depth++;
17736         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17737         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17738         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17739         ndr->depth--;
17740 }
17741
17742 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17743 {
17744         if (ndr_flags & NDR_SCALARS) {
17745                 NDR_CHECK(ndr_push_align(ndr, 4));
17746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17750                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17751                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17752                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17753         }
17754         if (ndr_flags & NDR_BUFFERS) {
17755                 if (r->client) {
17756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17759                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17760                 }
17761                 if (r->user) {
17762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17763                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17765                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17766                 }
17767         }
17768         return NDR_ERR_SUCCESS;
17769 }
17770
17771 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17772 {
17773         uint32_t _ptr_client;
17774         TALLOC_CTX *_mem_save_client_0;
17775         uint32_t _ptr_user;
17776         TALLOC_CTX *_mem_save_user_0;
17777         if (ndr_flags & NDR_SCALARS) {
17778                 NDR_CHECK(ndr_pull_align(ndr, 4));
17779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17780                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17781                 if (_ptr_client) {
17782                         NDR_PULL_ALLOC(ndr, r->client);
17783                 } else {
17784                         r->client = NULL;
17785                 }
17786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17787                 if (_ptr_user) {
17788                         NDR_PULL_ALLOC(ndr, r->user);
17789                 } else {
17790                         r->user = NULL;
17791                 }
17792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17793                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17794                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17795                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17796         }
17797         if (ndr_flags & NDR_BUFFERS) {
17798                 if (r->client) {
17799                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17800                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17802                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17803                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17804                                 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));
17805                         }
17806                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17807                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17809                 }
17810                 if (r->user) {
17811                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17812                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17815                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17816                                 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));
17817                         }
17818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17821                 }
17822         }
17823         return NDR_ERR_SUCCESS;
17824 }
17825
17826 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17827 {
17828         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17829         ndr->depth++;
17830         ndr_print_uint32(ndr, "size", r->size);
17831         ndr_print_ptr(ndr, "client", r->client);
17832         ndr->depth++;
17833         if (r->client) {
17834                 ndr_print_string(ndr, "client", r->client);
17835         }
17836         ndr->depth--;
17837         ndr_print_ptr(ndr, "user", r->user);
17838         ndr->depth++;
17839         if (r->user) {
17840                 ndr_print_string(ndr, "user", r->user);
17841         }
17842         ndr->depth--;
17843         ndr_print_uint32(ndr, "build", r->build);
17844         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17845         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17846         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17847         ndr->depth--;
17848 }
17849
17850 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17851 {
17852         if (ndr_flags & NDR_SCALARS) {
17853                 NDR_CHECK(ndr_push_align(ndr, 4));
17854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17855         }
17856         if (ndr_flags & NDR_BUFFERS) {
17857         }
17858         return NDR_ERR_SUCCESS;
17859 }
17860
17861 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17862 {
17863         if (ndr_flags & NDR_SCALARS) {
17864                 NDR_CHECK(ndr_pull_align(ndr, 4));
17865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17866         }
17867         if (ndr_flags & NDR_BUFFERS) {
17868         }
17869         return NDR_ERR_SUCCESS;
17870 }
17871
17872 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17873 {
17874         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17875         ndr->depth++;
17876         ndr_print_uint32(ndr, "not_used", r->not_used);
17877         ndr->depth--;
17878 }
17879
17880 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17881 {
17882         if (ndr_flags & NDR_SCALARS) {
17883                 NDR_CHECK(ndr_push_align(ndr, 4));
17884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17890                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17891                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17892                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17893                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17894         }
17895         if (ndr_flags & NDR_BUFFERS) {
17896                 if (r->client) {
17897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17901                 }
17902                 if (r->user) {
17903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17907                 }
17908         }
17909         return NDR_ERR_SUCCESS;
17910 }
17911
17912 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17913 {
17914         uint32_t _ptr_client;
17915         TALLOC_CTX *_mem_save_client_0;
17916         uint32_t _ptr_user;
17917         TALLOC_CTX *_mem_save_user_0;
17918         if (ndr_flags & NDR_SCALARS) {
17919                 NDR_CHECK(ndr_pull_align(ndr, 4));
17920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17924                 if (_ptr_client) {
17925                         NDR_PULL_ALLOC(ndr, r->client);
17926                 } else {
17927                         r->client = NULL;
17928                 }
17929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17930                 if (_ptr_user) {
17931                         NDR_PULL_ALLOC(ndr, r->user);
17932                 } else {
17933                         r->user = NULL;
17934                 }
17935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17936                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17937                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17938                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17939                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17940         }
17941         if (ndr_flags & NDR_BUFFERS) {
17942                 if (r->client) {
17943                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17944                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17947                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17948                                 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));
17949                         }
17950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17953                 }
17954                 if (r->user) {
17955                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17956                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17959                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17960                                 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));
17961                         }
17962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17965                 }
17966         }
17967         return NDR_ERR_SUCCESS;
17968 }
17969
17970 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17971 {
17972         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17973         ndr->depth++;
17974         ndr_print_uint32(ndr, "size", r->size);
17975         ndr_print_uint32(ndr, "flags", r->flags);
17976         ndr_print_uint32(ndr, "size2", r->size2);
17977         ndr_print_ptr(ndr, "client", r->client);
17978         ndr->depth++;
17979         if (r->client) {
17980                 ndr_print_string(ndr, "client", r->client);
17981         }
17982         ndr->depth--;
17983         ndr_print_ptr(ndr, "user", r->user);
17984         ndr->depth++;
17985         if (r->user) {
17986                 ndr_print_string(ndr, "user", r->user);
17987         }
17988         ndr->depth--;
17989         ndr_print_uint32(ndr, "build", r->build);
17990         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17991         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17992         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17993         ndr_print_udlong(ndr, "reserved", r->reserved);
17994         ndr->depth--;
17995 }
17996
17997 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
17998 {
17999         if (ndr_flags & NDR_SCALARS) {
18000                 int level = ndr_push_get_switch_value(ndr, r);
18001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18002                 switch (level) {
18003                         case 1: {
18004                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18005                         break; }
18006
18007                         case 2: {
18008                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18009                         break; }
18010
18011                         case 3: {
18012                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18013                         break; }
18014
18015                         default:
18016                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18017                 }
18018         }
18019         if (ndr_flags & NDR_BUFFERS) {
18020                 int level = ndr_push_get_switch_value(ndr, r);
18021                 switch (level) {
18022                         case 1:
18023                                 if (r->level1) {
18024                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18025                                 }
18026                         break;
18027
18028                         case 2:
18029                                 if (r->level2) {
18030                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18031                                 }
18032                         break;
18033
18034                         case 3:
18035                                 if (r->level3) {
18036                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18037                                 }
18038                         break;
18039
18040                         default:
18041                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18042                 }
18043         }
18044         return NDR_ERR_SUCCESS;
18045 }
18046
18047 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18048 {
18049         int level;
18050         uint32_t _level;
18051         TALLOC_CTX *_mem_save_level1_0;
18052         TALLOC_CTX *_mem_save_level2_0;
18053         TALLOC_CTX *_mem_save_level3_0;
18054         level = ndr_pull_get_switch_value(ndr, r);
18055         if (ndr_flags & NDR_SCALARS) {
18056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18057                 if (_level != level) {
18058                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18059                 }
18060                 switch (level) {
18061                         case 1: {
18062                                 uint32_t _ptr_level1;
18063                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18064                                 if (_ptr_level1) {
18065                                         NDR_PULL_ALLOC(ndr, r->level1);
18066                                 } else {
18067                                         r->level1 = NULL;
18068                                 }
18069                         break; }
18070
18071                         case 2: {
18072                                 uint32_t _ptr_level2;
18073                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18074                                 if (_ptr_level2) {
18075                                         NDR_PULL_ALLOC(ndr, r->level2);
18076                                 } else {
18077                                         r->level2 = NULL;
18078                                 }
18079                         break; }
18080
18081                         case 3: {
18082                                 uint32_t _ptr_level3;
18083                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18084                                 if (_ptr_level3) {
18085                                         NDR_PULL_ALLOC(ndr, r->level3);
18086                                 } else {
18087                                         r->level3 = NULL;
18088                                 }
18089                         break; }
18090
18091                         default:
18092                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18093                 }
18094         }
18095         if (ndr_flags & NDR_BUFFERS) {
18096                 switch (level) {
18097                         case 1:
18098                                 if (r->level1) {
18099                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18100                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18101                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18102                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18103                                 }
18104                         break;
18105
18106                         case 2:
18107                                 if (r->level2) {
18108                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18109                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18110                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18111                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18112                                 }
18113                         break;
18114
18115                         case 3:
18116                                 if (r->level3) {
18117                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18118                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18119                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18120                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18121                                 }
18122                         break;
18123
18124                         default:
18125                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18126                 }
18127         }
18128         return NDR_ERR_SUCCESS;
18129 }
18130
18131 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18132 {
18133         int level;
18134         level = ndr_print_get_switch_value(ndr, r);
18135         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18136         switch (level) {
18137                 case 1:
18138                         ndr_print_ptr(ndr, "level1", r->level1);
18139                         ndr->depth++;
18140                         if (r->level1) {
18141                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18142                         }
18143                         ndr->depth--;
18144                 break;
18145
18146                 case 2:
18147                         ndr_print_ptr(ndr, "level2", r->level2);
18148                         ndr->depth++;
18149                         if (r->level2) {
18150                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18151                         }
18152                         ndr->depth--;
18153                 break;
18154
18155                 case 3:
18156                         ndr_print_ptr(ndr, "level3", r->level3);
18157                         ndr->depth++;
18158                         if (r->level3) {
18159                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18160                         }
18161                         ndr->depth--;
18162                 break;
18163
18164                 default:
18165                         ndr_print_bad_level(ndr, name, level);
18166         }
18167 }
18168
18169 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18170 {
18171         if (ndr_flags & NDR_SCALARS) {
18172                 NDR_CHECK(ndr_push_align(ndr, 4));
18173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18174                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18175                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18176         }
18177         if (ndr_flags & NDR_BUFFERS) {
18178                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18179         }
18180         return NDR_ERR_SUCCESS;
18181 }
18182
18183 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18184 {
18185         if (ndr_flags & NDR_SCALARS) {
18186                 NDR_CHECK(ndr_pull_align(ndr, 4));
18187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18188                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18189                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18190         }
18191         if (ndr_flags & NDR_BUFFERS) {
18192                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18193         }
18194         return NDR_ERR_SUCCESS;
18195 }
18196
18197 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18198 {
18199         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18200         ndr->depth++;
18201         ndr_print_uint32(ndr, "level", r->level);
18202         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18203         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18204         ndr->depth--;
18205 }
18206
18207 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18208 {
18209         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18210         return NDR_ERR_SUCCESS;
18211 }
18212
18213 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18214 {
18215         uint32_t v;
18216         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18217         *r = v;
18218         return NDR_ERR_SUCCESS;
18219 }
18220
18221 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18222 {
18223         ndr_print_uint32(ndr, name, r);
18224         ndr->depth++;
18225         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18226         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18231         ndr->depth--;
18232 }
18233
18234 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
18235 {
18236         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18237         if (ndr_flags & NDR_SCALARS) {
18238                 NDR_CHECK(ndr_push_align(ndr, 4));
18239                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18240                 {
18241                         uint32_t _flags_save_string = ndr->flags;
18242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18243                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
18244                         ndr->flags = _flags_save_string;
18245                 }
18246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
18247                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
18248                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
18249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
18250         }
18251         if (ndr_flags & NDR_BUFFERS) {
18252                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18253                 {
18254                         uint32_t _flags_save_string = ndr->flags;
18255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18256                         if (r->value_name) {
18257                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
18258                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
18259                         }
18260                         ndr->flags = _flags_save_string;
18261                 }
18262                 if (r->data) {
18263                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
18264                         {
18265                                 struct ndr_push *_ndr_data;
18266                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18267                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
18268                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18269                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18270                         }
18271                 }
18272         }
18273         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18274         return NDR_ERR_SUCCESS;
18275 }
18276
18277 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
18278 {
18279         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18280         uint32_t _ptr_value_name;
18281         TALLOC_CTX *_mem_save_value_name_0;
18282         uint32_t _ptr_data;
18283         TALLOC_CTX *_mem_save_data_0;
18284         if (ndr_flags & NDR_SCALARS) {
18285                 NDR_CHECK(ndr_pull_align(ndr, 4));
18286                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18287                 {
18288                         uint32_t _flags_save_string = ndr->flags;
18289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18290                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
18291                         if (_ptr_value_name) {
18292                                 NDR_PULL_ALLOC(ndr, r->value_name);
18293                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
18294                         } else {
18295                                 r->value_name = NULL;
18296                         }
18297                         ndr->flags = _flags_save_string;
18298                 }
18299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
18300                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
18301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
18302                 if (_ptr_data) {
18303                         NDR_PULL_ALLOC(ndr, r->data);
18304                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
18305                 } else {
18306                         r->data = NULL;
18307                 }
18308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
18309         }
18310         if (ndr_flags & NDR_BUFFERS) {
18311                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18312                 {
18313                         uint32_t _flags_save_string = ndr->flags;
18314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18315                         if (r->value_name) {
18316                                 uint32_t _relative_save_offset;
18317                                 _relative_save_offset = ndr->offset;
18318                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
18319                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18320                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
18321                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
18322                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
18323                                 ndr->offset = _relative_save_offset;
18324                         }
18325                         ndr->flags = _flags_save_string;
18326                 }
18327                 if (r->data) {
18328                         uint32_t _relative_save_offset;
18329                         _relative_save_offset = ndr->offset;
18330                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
18331                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
18332                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
18333                         {
18334                                 struct ndr_pull *_ndr_data;
18335                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18336                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
18337                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18338                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18339                         }
18340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
18341                         ndr->offset = _relative_save_offset;
18342                 }
18343         }
18344         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18345         return NDR_ERR_SUCCESS;
18346 }
18347
18348 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
18349 {
18350         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
18351         ndr->depth++;
18352         ndr_print_ptr(ndr, "value_name", r->value_name);
18353         ndr->depth++;
18354         if (r->value_name) {
18355                 ndr_print_string(ndr, "value_name", r->value_name);
18356         }
18357         ndr->depth--;
18358         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
18359         ndr_print_winreg_Type(ndr, "type", r->type);
18360         ndr_print_ptr(ndr, "data", r->data);
18361         ndr->depth++;
18362         if (r->data) {
18363                 ndr_print_set_switch_value(ndr, r->data, r->type);
18364                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
18365         }
18366         ndr->depth--;
18367         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);
18368         ndr->depth--;
18369 }
18370
18371 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
18372 {
18373         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
18374 }
18375
18376 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18377 {
18378         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18379         return NDR_ERR_SUCCESS;
18380 }
18381
18382 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18383 {
18384         uint32_t v;
18385         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18386         *r = v;
18387         return NDR_ERR_SUCCESS;
18388 }
18389
18390 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18391 {
18392         ndr_print_uint32(ndr, name, r);
18393         ndr->depth++;
18394         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18395         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18396         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18397         ndr->depth--;
18398 }
18399
18400 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18401 {
18402         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18403         return NDR_ERR_SUCCESS;
18404 }
18405
18406 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18407 {
18408         uint32_t v;
18409         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18410         *r = v;
18411         return NDR_ERR_SUCCESS;
18412 }
18413
18414 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18415 {
18416         const char *val = NULL;
18417
18418         switch (r) {
18419                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18420                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18421         }
18422         ndr_print_enum(ndr, name, "ENUM", val, r);
18423 }
18424
18425 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18426 {
18427         if (ndr_flags & NDR_SCALARS) {
18428                 NDR_CHECK(ndr_push_align(ndr, 4));
18429                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18431                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18434                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18435                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18437                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18438                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18439                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18440                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18444         }
18445         if (ndr_flags & NDR_BUFFERS) {
18446         }
18447         return NDR_ERR_SUCCESS;
18448 }
18449
18450 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18451 {
18452         if (ndr_flags & NDR_SCALARS) {
18453                 NDR_CHECK(ndr_pull_align(ndr, 4));
18454                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18456                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18459                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18460                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18462                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18463                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18464                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18465                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18469         }
18470         if (ndr_flags & NDR_BUFFERS) {
18471         }
18472         return NDR_ERR_SUCCESS;
18473 }
18474
18475 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18476 {
18477         ndr_print_struct(ndr, name, "spoolss_PortData1");
18478         ndr->depth++;
18479         ndr_print_string(ndr, "portname", r->portname);
18480         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18481         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18482         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18483         ndr_print_uint32(ndr, "reserved", r->reserved);
18484         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18485         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18486         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18487         ndr_print_string(ndr, "queue", r->queue);
18488         ndr_print_string(ndr, "ip_address", r->ip_address);
18489         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18490         ndr_print_string(ndr, "device_type", r->device_type);
18491         ndr_print_uint32(ndr, "port_number", r->port_number);
18492         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18493         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18494         ndr->depth--;
18495 }
18496
18497 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18498 {
18499         if (ndr_flags & NDR_SCALARS) {
18500                 NDR_CHECK(ndr_push_align(ndr, 4));
18501                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18503                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18506                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18507                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18509                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18510                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18515         }
18516         if (ndr_flags & NDR_BUFFERS) {
18517         }
18518         return NDR_ERR_SUCCESS;
18519 }
18520
18521 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18522 {
18523         if (ndr_flags & NDR_SCALARS) {
18524                 NDR_CHECK(ndr_pull_align(ndr, 4));
18525                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18527                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18530                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18531                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18533                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18534                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18539         }
18540         if (ndr_flags & NDR_BUFFERS) {
18541         }
18542         return NDR_ERR_SUCCESS;
18543 }
18544
18545 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18546 {
18547         ndr_print_struct(ndr, name, "spoolss_PortData2");
18548         ndr->depth++;
18549         ndr_print_string(ndr, "portname", r->portname);
18550         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18551         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18552         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18553         ndr_print_uint32(ndr, "reserved", r->reserved);
18554         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18555         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18556         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18557         ndr_print_string(ndr, "queue", r->queue);
18558         ndr_print_string(ndr, "device_type", r->device_type);
18559         ndr_print_uint32(ndr, "port_number", r->port_number);
18560         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18561         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18562         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18563         ndr->depth--;
18564 }
18565
18566 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18567 {
18568         if (ndr_flags & NDR_SCALARS) {
18569                 NDR_CHECK(ndr_push_align(ndr, 4));
18570                 {
18571                         uint32_t _flags_save_string = ndr->flags;
18572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18573                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18574                         ndr->flags = _flags_save_string;
18575                 }
18576         }
18577         if (ndr_flags & NDR_BUFFERS) {
18578         }
18579         return NDR_ERR_SUCCESS;
18580 }
18581
18582 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18583 {
18584         if (ndr_flags & NDR_SCALARS) {
18585                 NDR_CHECK(ndr_pull_align(ndr, 4));
18586                 {
18587                         uint32_t _flags_save_string = ndr->flags;
18588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18589                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18590                         ndr->flags = _flags_save_string;
18591                 }
18592         }
18593         if (ndr_flags & NDR_BUFFERS) {
18594         }
18595         return NDR_ERR_SUCCESS;
18596 }
18597
18598 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18599 {
18600         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18601         ndr->depth++;
18602         ndr_print_string(ndr, "dll_name", r->dll_name);
18603         ndr->depth--;
18604 }
18605
18606 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18607 {
18608         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18609         return NDR_ERR_SUCCESS;
18610 }
18611
18612 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18613 {
18614         uint32_t v;
18615         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18616         *r = v;
18617         return NDR_ERR_SUCCESS;
18618 }
18619
18620 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18621 {
18622         ndr_print_uint32(ndr, name, r);
18623         ndr->depth++;
18624         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18625         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18626         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18627         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18628         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18629         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18630         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18631         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18632         ndr->depth--;
18633 }
18634
18635 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18636 {
18637         if (flags & NDR_IN) {
18638                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18639                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18640                 if (r->in.server) {
18641                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18644                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18645                 }
18646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18648                 if (r->in.buffer) {
18649                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18650                 }
18651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18652         }
18653         if (flags & NDR_OUT) {
18654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18655                 if (r->out.info) {
18656                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18657                 }
18658                 if (r->out.needed == NULL) {
18659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18660                 }
18661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18662                 if (r->out.count == NULL) {
18663                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18664                 }
18665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18666                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18667         }
18668         return NDR_ERR_SUCCESS;
18669 }
18670
18671 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18672 {
18673         uint32_t _ptr_server;
18674         uint32_t _ptr_buffer;
18675         uint32_t _ptr_info;
18676         TALLOC_CTX *_mem_save_server_0;
18677         TALLOC_CTX *_mem_save_buffer_0;
18678         TALLOC_CTX *_mem_save_info_0;
18679         TALLOC_CTX *_mem_save_needed_0;
18680         TALLOC_CTX *_mem_save_count_0;
18681         if (flags & NDR_IN) {
18682                 ZERO_STRUCT(r->out);
18683
18684                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18686                 if (_ptr_server) {
18687                         NDR_PULL_ALLOC(ndr, r->in.server);
18688                 } else {
18689                         r->in.server = NULL;
18690                 }
18691                 if (r->in.server) {
18692                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18693                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18694                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18695                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18696                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18697                                 return 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));
18698                         }
18699                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18700                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18701                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18702                 }
18703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18705                 if (_ptr_buffer) {
18706                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18707                 } else {
18708                         r->in.buffer = NULL;
18709                 }
18710                 if (r->in.buffer) {
18711                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18712                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18713                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18714                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18715                 }
18716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18717                 NDR_PULL_ALLOC(ndr, r->out.needed);
18718                 ZERO_STRUCTP(r->out.needed);
18719                 NDR_PULL_ALLOC(ndr, r->out.count);
18720                 ZERO_STRUCTP(r->out.count);
18721         }
18722         if (flags & NDR_OUT) {
18723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18724                 if (_ptr_info) {
18725                         NDR_PULL_ALLOC(ndr, r->out.info);
18726                 } else {
18727                         r->out.info = NULL;
18728                 }
18729                 if (r->out.info) {
18730                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18731                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18732                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18734                 }
18735                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18736                         NDR_PULL_ALLOC(ndr, r->out.needed);
18737                 }
18738                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18739                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18741                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18743                         NDR_PULL_ALLOC(ndr, r->out.count);
18744                 }
18745                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18746                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18749                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18750         }
18751         return NDR_ERR_SUCCESS;
18752 }
18753
18754 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18755 {
18756         uint32_t cntr_info_0;
18757         if (flags & NDR_IN) {
18758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18760         }
18761         if (flags & NDR_OUT) {
18762                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18763                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18764                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18765                 }
18766                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18767                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18768                 }
18769         }
18770         return NDR_ERR_SUCCESS;
18771 }
18772
18773 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18774 {
18775         uint32_t cntr_info_0;
18776         TALLOC_CTX *_mem_save_info_0;
18777         if (flags & NDR_IN) {
18778                 ZERO_STRUCT(r->out);
18779
18780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18782         }
18783         if (flags & NDR_OUT) {
18784                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18785                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18786                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18787                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18788                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18789                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18790                 }
18791                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18792                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18793                 }
18794                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18795         }
18796         return NDR_ERR_SUCCESS;
18797 }
18798
18799 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18800 {
18801         uint32_t cntr_info_2;
18802         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18803         ndr->depth++;
18804         if (flags & NDR_SET_VALUES) {
18805                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18806         }
18807         if (flags & NDR_IN) {
18808                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18809                 ndr->depth++;
18810                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18811                 ndr_print_ptr(ndr, "server", r->in.server);
18812                 ndr->depth++;
18813                 if (r->in.server) {
18814                         ndr_print_string(ndr, "server", r->in.server);
18815                 }
18816                 ndr->depth--;
18817                 ndr_print_uint32(ndr, "level", r->in.level);
18818                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18819                 ndr->depth++;
18820                 if (r->in.buffer) {
18821                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18822                 }
18823                 ndr->depth--;
18824                 ndr_print_uint32(ndr, "offered", r->in.offered);
18825                 ndr->depth--;
18826         }
18827         if (flags & NDR_OUT) {
18828                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18829                 ndr->depth++;
18830                 ndr_print_ptr(ndr, "count", r->out.count);
18831                 ndr->depth++;
18832                 ndr_print_uint32(ndr, "count", *r->out.count);
18833                 ndr->depth--;
18834                 ndr_print_ptr(ndr, "info", r->out.info);
18835                 ndr->depth++;
18836                 ndr_print_ptr(ndr, "info", *r->out.info);
18837                 ndr->depth++;
18838                 if (*r->out.info) {
18839                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18840                         ndr->depth++;
18841                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18842                                 char *idx_2=NULL;
18843                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18844                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18845                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18846                                         free(idx_2);
18847                                 }
18848                         }
18849                         ndr->depth--;
18850                 }
18851                 ndr->depth--;
18852                 ndr->depth--;
18853                 ndr_print_ptr(ndr, "needed", r->out.needed);
18854                 ndr->depth++;
18855                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18856                 ndr->depth--;
18857                 ndr_print_WERROR(ndr, "result", r->out.result);
18858                 ndr->depth--;
18859         }
18860         ndr->depth--;
18861 }
18862
18863 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18864 {
18865         if (flags & NDR_IN) {
18866                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18867                 if (r->in.printername) {
18868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18872                 }
18873                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18874                 if (r->in.datatype) {
18875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18876                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18877                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18878                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18879                 }
18880                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18881                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18882         }
18883         if (flags & NDR_OUT) {
18884                 if (r->out.handle == NULL) {
18885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18886                 }
18887                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18888                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18889         }
18890         return NDR_ERR_SUCCESS;
18891 }
18892
18893 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18894 {
18895         uint32_t _ptr_printername;
18896         uint32_t _ptr_datatype;
18897         TALLOC_CTX *_mem_save_printername_0;
18898         TALLOC_CTX *_mem_save_datatype_0;
18899         TALLOC_CTX *_mem_save_handle_0;
18900         if (flags & NDR_IN) {
18901                 ZERO_STRUCT(r->out);
18902
18903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18904                 if (_ptr_printername) {
18905                         NDR_PULL_ALLOC(ndr, r->in.printername);
18906                 } else {
18907                         r->in.printername = NULL;
18908                 }
18909                 if (r->in.printername) {
18910                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18911                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18912                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18913                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18914                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18915                                 return 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));
18916                         }
18917                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18918                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18920                 }
18921                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18922                 if (_ptr_datatype) {
18923                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18924                 } else {
18925                         r->in.datatype = NULL;
18926                 }
18927                 if (r->in.datatype) {
18928                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18929                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18931                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18932                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18933                                 return 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));
18934                         }
18935                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18936                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18938                 }
18939                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18940                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18941                 NDR_PULL_ALLOC(ndr, r->out.handle);
18942                 ZERO_STRUCTP(r->out.handle);
18943         }
18944         if (flags & NDR_OUT) {
18945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18946                         NDR_PULL_ALLOC(ndr, r->out.handle);
18947                 }
18948                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18949                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18950                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18952                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18953         }
18954         return NDR_ERR_SUCCESS;
18955 }
18956
18957 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18958 {
18959         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18960         ndr->depth++;
18961         if (flags & NDR_SET_VALUES) {
18962                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18963         }
18964         if (flags & NDR_IN) {
18965                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18966                 ndr->depth++;
18967                 ndr_print_ptr(ndr, "printername", r->in.printername);
18968                 ndr->depth++;
18969                 if (r->in.printername) {
18970                         ndr_print_string(ndr, "printername", r->in.printername);
18971                 }
18972                 ndr->depth--;
18973                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18974                 ndr->depth++;
18975                 if (r->in.datatype) {
18976                         ndr_print_string(ndr, "datatype", r->in.datatype);
18977                 }
18978                 ndr->depth--;
18979                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18980                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18981                 ndr->depth--;
18982         }
18983         if (flags & NDR_OUT) {
18984                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18985                 ndr->depth++;
18986                 ndr_print_ptr(ndr, "handle", r->out.handle);
18987                 ndr->depth++;
18988                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18989                 ndr->depth--;
18990                 ndr_print_WERROR(ndr, "result", r->out.result);
18991                 ndr->depth--;
18992         }
18993         ndr->depth--;
18994 }
18995
18996 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18997 {
18998         if (flags & NDR_IN) {
18999                 if (r->in.handle == NULL) {
19000                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19001                 }
19002                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19005                 if (r->in.ctr) {
19006                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19007                 }
19008                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19009         }
19010         if (flags & NDR_OUT) {
19011                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19012         }
19013         return NDR_ERR_SUCCESS;
19014 }
19015
19016 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19017 {
19018         uint32_t _ptr_ctr;
19019         TALLOC_CTX *_mem_save_handle_0;
19020         TALLOC_CTX *_mem_save_ctr_0;
19021         if (flags & NDR_IN) {
19022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19023                         NDR_PULL_ALLOC(ndr, r->in.handle);
19024                 }
19025                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19026                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19027                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19031                 if (_ptr_ctr) {
19032                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19033                 } else {
19034                         r->in.ctr = NULL;
19035                 }
19036                 if (r->in.ctr) {
19037                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19038                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
19039                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
19041                 }
19042                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
19043         }
19044         if (flags & NDR_OUT) {
19045                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19046         }
19047         return NDR_ERR_SUCCESS;
19048 }
19049
19050 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
19051 {
19052         ndr_print_struct(ndr, name, "spoolss_SetJob");
19053         ndr->depth++;
19054         if (flags & NDR_SET_VALUES) {
19055                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19056         }
19057         if (flags & NDR_IN) {
19058                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
19059                 ndr->depth++;
19060                 ndr_print_ptr(ndr, "handle", r->in.handle);
19061                 ndr->depth++;
19062                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19063                 ndr->depth--;
19064                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19065                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
19066                 ndr->depth++;
19067                 if (r->in.ctr) {
19068                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
19069                 }
19070                 ndr->depth--;
19071                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
19072                 ndr->depth--;
19073         }
19074         if (flags & NDR_OUT) {
19075                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
19076                 ndr->depth++;
19077                 ndr_print_WERROR(ndr, "result", r->out.result);
19078                 ndr->depth--;
19079         }
19080         ndr->depth--;
19081 }
19082
19083 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
19084 {
19085         if (flags & NDR_IN) {
19086                 if (r->in.handle == NULL) {
19087                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19088                 }
19089                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19093                 if (r->in.buffer) {
19094                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19095                 }
19096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19097         }
19098         if (flags & NDR_OUT) {
19099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19100                 if (r->out.info) {
19101                         {
19102                                 struct ndr_push *_ndr_info;
19103                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19104                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19105                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19106                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19107                         }
19108                 }
19109                 if (r->out.needed == NULL) {
19110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19111                 }
19112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19114         }
19115         return NDR_ERR_SUCCESS;
19116 }
19117
19118 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
19119 {
19120         uint32_t _ptr_buffer;
19121         uint32_t _ptr_info;
19122         TALLOC_CTX *_mem_save_handle_0;
19123         TALLOC_CTX *_mem_save_buffer_0;
19124         TALLOC_CTX *_mem_save_info_0;
19125         TALLOC_CTX *_mem_save_needed_0;
19126         if (flags & NDR_IN) {
19127                 ZERO_STRUCT(r->out);
19128
19129                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19130                         NDR_PULL_ALLOC(ndr, r->in.handle);
19131                 }
19132                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19133                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19134                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19139                 if (_ptr_buffer) {
19140                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19141                 } else {
19142                         r->in.buffer = NULL;
19143                 }
19144                 if (r->in.buffer) {
19145                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19146                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19147                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19149                 }
19150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19151                 NDR_PULL_ALLOC(ndr, r->out.needed);
19152                 ZERO_STRUCTP(r->out.needed);
19153         }
19154         if (flags & NDR_OUT) {
19155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19156                 if (_ptr_info) {
19157                         NDR_PULL_ALLOC(ndr, r->out.info);
19158                 } else {
19159                         r->out.info = NULL;
19160                 }
19161                 if (r->out.info) {
19162                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19163                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19164                         {
19165                                 struct ndr_pull *_ndr_info;
19166                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19167                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19168                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19169                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19170                         }
19171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19172                 }
19173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19174                         NDR_PULL_ALLOC(ndr, r->out.needed);
19175                 }
19176                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19177                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19179                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19180                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19181         }
19182         return NDR_ERR_SUCCESS;
19183 }
19184
19185 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19186 {
19187         ndr_print_struct(ndr, name, "spoolss_GetJob");
19188         ndr->depth++;
19189         if (flags & NDR_SET_VALUES) {
19190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19191         }
19192         if (flags & NDR_IN) {
19193                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19194                 ndr->depth++;
19195                 ndr_print_ptr(ndr, "handle", r->in.handle);
19196                 ndr->depth++;
19197                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19198                 ndr->depth--;
19199                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19200                 ndr_print_uint32(ndr, "level", r->in.level);
19201                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19202                 ndr->depth++;
19203                 if (r->in.buffer) {
19204                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19205                 }
19206                 ndr->depth--;
19207                 ndr_print_uint32(ndr, "offered", r->in.offered);
19208                 ndr->depth--;
19209         }
19210         if (flags & NDR_OUT) {
19211                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19212                 ndr->depth++;
19213                 ndr_print_ptr(ndr, "info", r->out.info);
19214                 ndr->depth++;
19215                 if (r->out.info) {
19216                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19217                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19218                 }
19219                 ndr->depth--;
19220                 ndr_print_ptr(ndr, "needed", r->out.needed);
19221                 ndr->depth++;
19222                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19223                 ndr->depth--;
19224                 ndr_print_WERROR(ndr, "result", r->out.result);
19225                 ndr->depth--;
19226         }
19227         ndr->depth--;
19228 }
19229
19230 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19231 {
19232         if (flags & NDR_IN) {
19233                 if (r->in.handle == NULL) {
19234                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19235                 }
19236                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19240                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19241                 if (r->in.buffer) {
19242                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19243                 }
19244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19245         }
19246         if (flags & NDR_OUT) {
19247                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19248                 if (r->out.info) {
19249                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19250                 }
19251                 if (r->out.needed == NULL) {
19252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19253                 }
19254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19255                 if (r->out.count == NULL) {
19256                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19257                 }
19258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19260         }
19261         return NDR_ERR_SUCCESS;
19262 }
19263
19264 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19265 {
19266         uint32_t _ptr_buffer;
19267         uint32_t _ptr_info;
19268         TALLOC_CTX *_mem_save_handle_0;
19269         TALLOC_CTX *_mem_save_buffer_0;
19270         TALLOC_CTX *_mem_save_info_0;
19271         TALLOC_CTX *_mem_save_needed_0;
19272         TALLOC_CTX *_mem_save_count_0;
19273         if (flags & NDR_IN) {
19274                 ZERO_STRUCT(r->out);
19275
19276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19277                         NDR_PULL_ALLOC(ndr, r->in.handle);
19278                 }
19279                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19280                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19281                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19282                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19287                 if (_ptr_buffer) {
19288                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19289                 } else {
19290                         r->in.buffer = NULL;
19291                 }
19292                 if (r->in.buffer) {
19293                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19294                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19295                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19297                 }
19298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19299                 NDR_PULL_ALLOC(ndr, r->out.needed);
19300                 ZERO_STRUCTP(r->out.needed);
19301                 NDR_PULL_ALLOC(ndr, r->out.count);
19302                 ZERO_STRUCTP(r->out.count);
19303         }
19304         if (flags & NDR_OUT) {
19305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19306                 if (_ptr_info) {
19307                         NDR_PULL_ALLOC(ndr, r->out.info);
19308                 } else {
19309                         r->out.info = NULL;
19310                 }
19311                 if (r->out.info) {
19312                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19313                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19314                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19316                 }
19317                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19318                         NDR_PULL_ALLOC(ndr, r->out.needed);
19319                 }
19320                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19321                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19325                         NDR_PULL_ALLOC(ndr, r->out.count);
19326                 }
19327                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19328                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19331                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19332         }
19333         return NDR_ERR_SUCCESS;
19334 }
19335
19336 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19337 {
19338         uint32_t cntr_info_0;
19339         if (flags & NDR_IN) {
19340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19342         }
19343         if (flags & NDR_OUT) {
19344                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19345                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19346                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19347                 }
19348                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19349                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19350                 }
19351         }
19352         return NDR_ERR_SUCCESS;
19353 }
19354
19355 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19356 {
19357         uint32_t cntr_info_0;
19358         TALLOC_CTX *_mem_save_info_0;
19359         if (flags & NDR_IN) {
19360                 ZERO_STRUCT(r->out);
19361
19362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19364         }
19365         if (flags & NDR_OUT) {
19366                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19367                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19368                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19369                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19370                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19371                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19372                 }
19373                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19374                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19375                 }
19376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19377         }
19378         return NDR_ERR_SUCCESS;
19379 }
19380
19381 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19382 {
19383         uint32_t cntr_info_2;
19384         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19385         ndr->depth++;
19386         if (flags & NDR_SET_VALUES) {
19387                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19388         }
19389         if (flags & NDR_IN) {
19390                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19391                 ndr->depth++;
19392                 ndr_print_ptr(ndr, "handle", r->in.handle);
19393                 ndr->depth++;
19394                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19395                 ndr->depth--;
19396                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19397                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19398                 ndr_print_uint32(ndr, "level", r->in.level);
19399                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19400                 ndr->depth++;
19401                 if (r->in.buffer) {
19402                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19403                 }
19404                 ndr->depth--;
19405                 ndr_print_uint32(ndr, "offered", r->in.offered);
19406                 ndr->depth--;
19407         }
19408         if (flags & NDR_OUT) {
19409                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19410                 ndr->depth++;
19411                 ndr_print_ptr(ndr, "count", r->out.count);
19412                 ndr->depth++;
19413                 ndr_print_uint32(ndr, "count", *r->out.count);
19414                 ndr->depth--;
19415                 ndr_print_ptr(ndr, "info", r->out.info);
19416                 ndr->depth++;
19417                 ndr_print_ptr(ndr, "info", *r->out.info);
19418                 ndr->depth++;
19419                 if (*r->out.info) {
19420                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19421                         ndr->depth++;
19422                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19423                                 char *idx_2=NULL;
19424                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19425                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19426                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19427                                         free(idx_2);
19428                                 }
19429                         }
19430                         ndr->depth--;
19431                 }
19432                 ndr->depth--;
19433                 ndr->depth--;
19434                 ndr_print_ptr(ndr, "needed", r->out.needed);
19435                 ndr->depth++;
19436                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19437                 ndr->depth--;
19438                 ndr_print_WERROR(ndr, "result", r->out.result);
19439                 ndr->depth--;
19440         }
19441         ndr->depth--;
19442 }
19443
19444 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19445 {
19446         if (flags & NDR_IN) {
19447         }
19448         if (flags & NDR_OUT) {
19449                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19450         }
19451         return NDR_ERR_SUCCESS;
19452 }
19453
19454 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19455 {
19456         if (flags & NDR_IN) {
19457         }
19458         if (flags & NDR_OUT) {
19459                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19460         }
19461         return NDR_ERR_SUCCESS;
19462 }
19463
19464 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19465 {
19466         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19467         ndr->depth++;
19468         if (flags & NDR_SET_VALUES) {
19469                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19470         }
19471         if (flags & NDR_IN) {
19472                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19473                 ndr->depth++;
19474                 ndr->depth--;
19475         }
19476         if (flags & NDR_OUT) {
19477                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19478                 ndr->depth++;
19479                 ndr_print_WERROR(ndr, "result", r->out.result);
19480                 ndr->depth--;
19481         }
19482         ndr->depth--;
19483 }
19484
19485 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19486 {
19487         if (flags & NDR_IN) {
19488                 if (r->in.handle == NULL) {
19489                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19490                 }
19491                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19492         }
19493         if (flags & NDR_OUT) {
19494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19495         }
19496         return NDR_ERR_SUCCESS;
19497 }
19498
19499 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19500 {
19501         TALLOC_CTX *_mem_save_handle_0;
19502         if (flags & NDR_IN) {
19503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19504                         NDR_PULL_ALLOC(ndr, r->in.handle);
19505                 }
19506                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19507                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19508                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19509                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19510         }
19511         if (flags & NDR_OUT) {
19512                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19513         }
19514         return NDR_ERR_SUCCESS;
19515 }
19516
19517 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19518 {
19519         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19520         ndr->depth++;
19521         if (flags & NDR_SET_VALUES) {
19522                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19523         }
19524         if (flags & NDR_IN) {
19525                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19526                 ndr->depth++;
19527                 ndr_print_ptr(ndr, "handle", r->in.handle);
19528                 ndr->depth++;
19529                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19530                 ndr->depth--;
19531                 ndr->depth--;
19532         }
19533         if (flags & NDR_OUT) {
19534                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19535                 ndr->depth++;
19536                 ndr_print_WERROR(ndr, "result", r->out.result);
19537                 ndr->depth--;
19538         }
19539         ndr->depth--;
19540 }
19541
19542 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19543 {
19544         if (flags & NDR_IN) {
19545                 if (r->in.handle == NULL) {
19546                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19547                 }
19548                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19549                 if (r->in.info_ctr == NULL) {
19550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19551                 }
19552                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19553                 if (r->in.devmode_ctr == NULL) {
19554                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19555                 }
19556                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19557                 if (r->in.secdesc_ctr == NULL) {
19558                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19559                 }
19560                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19561                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19562         }
19563         if (flags & NDR_OUT) {
19564                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19565         }
19566         return NDR_ERR_SUCCESS;
19567 }
19568
19569 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19570 {
19571         TALLOC_CTX *_mem_save_handle_0;
19572         TALLOC_CTX *_mem_save_info_ctr_0;
19573         TALLOC_CTX *_mem_save_devmode_ctr_0;
19574         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19575         if (flags & NDR_IN) {
19576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19577                         NDR_PULL_ALLOC(ndr, r->in.handle);
19578                 }
19579                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19580                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19581                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19582                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19583                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19584                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19585                 }
19586                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19587                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19588                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19589                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19591                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19592                 }
19593                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19594                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19595                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19598                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19599                 }
19600                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19601                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19602                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19604                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19605         }
19606         if (flags & NDR_OUT) {
19607                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19608         }
19609         return NDR_ERR_SUCCESS;
19610 }
19611
19612 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19613 {
19614         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19615         ndr->depth++;
19616         if (flags & NDR_SET_VALUES) {
19617                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19618         }
19619         if (flags & NDR_IN) {
19620                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19621                 ndr->depth++;
19622                 ndr_print_ptr(ndr, "handle", r->in.handle);
19623                 ndr->depth++;
19624                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19625                 ndr->depth--;
19626                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19627                 ndr->depth++;
19628                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19629                 ndr->depth--;
19630                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19631                 ndr->depth++;
19632                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19633                 ndr->depth--;
19634                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19635                 ndr->depth++;
19636                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19637                 ndr->depth--;
19638                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19639                 ndr->depth--;
19640         }
19641         if (flags & NDR_OUT) {
19642                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19643                 ndr->depth++;
19644                 ndr_print_WERROR(ndr, "result", r->out.result);
19645                 ndr->depth--;
19646         }
19647         ndr->depth--;
19648 }
19649
19650 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19651 {
19652         if (flags & NDR_IN) {
19653                 if (r->in.handle == NULL) {
19654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19655                 }
19656                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19659                 if (r->in.buffer) {
19660                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19661                 }
19662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19663         }
19664         if (flags & NDR_OUT) {
19665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19666                 if (r->out.info) {
19667                         {
19668                                 struct ndr_push *_ndr_info;
19669                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19670                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19671                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19672                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19673                         }
19674                 }
19675                 if (r->out.needed == NULL) {
19676                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19677                 }
19678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19679                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19680         }
19681         return NDR_ERR_SUCCESS;
19682 }
19683
19684 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19685 {
19686         uint32_t _ptr_buffer;
19687         uint32_t _ptr_info;
19688         TALLOC_CTX *_mem_save_handle_0;
19689         TALLOC_CTX *_mem_save_buffer_0;
19690         TALLOC_CTX *_mem_save_info_0;
19691         TALLOC_CTX *_mem_save_needed_0;
19692         if (flags & NDR_IN) {
19693                 ZERO_STRUCT(r->out);
19694
19695                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19696                         NDR_PULL_ALLOC(ndr, r->in.handle);
19697                 }
19698                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19699                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19700                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19701                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19704                 if (_ptr_buffer) {
19705                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19706                 } else {
19707                         r->in.buffer = NULL;
19708                 }
19709                 if (r->in.buffer) {
19710                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19711                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19712                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19714                 }
19715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19716                 NDR_PULL_ALLOC(ndr, r->out.needed);
19717                 ZERO_STRUCTP(r->out.needed);
19718         }
19719         if (flags & NDR_OUT) {
19720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19721                 if (_ptr_info) {
19722                         NDR_PULL_ALLOC(ndr, r->out.info);
19723                 } else {
19724                         r->out.info = NULL;
19725                 }
19726                 if (r->out.info) {
19727                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19728                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19729                         {
19730                                 struct ndr_pull *_ndr_info;
19731                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19732                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19733                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19734                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19735                         }
19736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19737                 }
19738                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19739                         NDR_PULL_ALLOC(ndr, r->out.needed);
19740                 }
19741                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19742                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19744                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19745                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19746         }
19747         return NDR_ERR_SUCCESS;
19748 }
19749
19750 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19751 {
19752         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19753         ndr->depth++;
19754         if (flags & NDR_SET_VALUES) {
19755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19756         }
19757         if (flags & NDR_IN) {
19758                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19759                 ndr->depth++;
19760                 ndr_print_ptr(ndr, "handle", r->in.handle);
19761                 ndr->depth++;
19762                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19763                 ndr->depth--;
19764                 ndr_print_uint32(ndr, "level", r->in.level);
19765                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19766                 ndr->depth++;
19767                 if (r->in.buffer) {
19768                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19769                 }
19770                 ndr->depth--;
19771                 ndr_print_uint32(ndr, "offered", r->in.offered);
19772                 ndr->depth--;
19773         }
19774         if (flags & NDR_OUT) {
19775                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19776                 ndr->depth++;
19777                 ndr_print_ptr(ndr, "info", r->out.info);
19778                 ndr->depth++;
19779                 if (r->out.info) {
19780                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19781                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19782                 }
19783                 ndr->depth--;
19784                 ndr_print_ptr(ndr, "needed", r->out.needed);
19785                 ndr->depth++;
19786                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19787                 ndr->depth--;
19788                 ndr_print_WERROR(ndr, "result", r->out.result);
19789                 ndr->depth--;
19790         }
19791         ndr->depth--;
19792 }
19793
19794 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19795 {
19796         if (flags & NDR_IN) {
19797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19798                 if (r->in.servername) {
19799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19800                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19802                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19803                 }
19804                 if (r->in.info_ctr == NULL) {
19805                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19806                 }
19807                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19808         }
19809         if (flags & NDR_OUT) {
19810                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19811         }
19812         return NDR_ERR_SUCCESS;
19813 }
19814
19815 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19816 {
19817         uint32_t _ptr_servername;
19818         TALLOC_CTX *_mem_save_servername_0;
19819         TALLOC_CTX *_mem_save_info_ctr_0;
19820         if (flags & NDR_IN) {
19821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19822                 if (_ptr_servername) {
19823                         NDR_PULL_ALLOC(ndr, r->in.servername);
19824                 } else {
19825                         r->in.servername = NULL;
19826                 }
19827                 if (r->in.servername) {
19828                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19829                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19831                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19832                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19833                                 return 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));
19834                         }
19835                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19836                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19838                 }
19839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19840                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19841                 }
19842                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19843                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19844                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19846         }
19847         if (flags & NDR_OUT) {
19848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19849         }
19850         return NDR_ERR_SUCCESS;
19851 }
19852
19853 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19854 {
19855         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19856         ndr->depth++;
19857         if (flags & NDR_SET_VALUES) {
19858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19859         }
19860         if (flags & NDR_IN) {
19861                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19862                 ndr->depth++;
19863                 ndr_print_ptr(ndr, "servername", r->in.servername);
19864                 ndr->depth++;
19865                 if (r->in.servername) {
19866                         ndr_print_string(ndr, "servername", r->in.servername);
19867                 }
19868                 ndr->depth--;
19869                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19870                 ndr->depth++;
19871                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19872                 ndr->depth--;
19873                 ndr->depth--;
19874         }
19875         if (flags & NDR_OUT) {
19876                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19877                 ndr->depth++;
19878                 ndr_print_WERROR(ndr, "result", r->out.result);
19879                 ndr->depth--;
19880         }
19881         ndr->depth--;
19882 }
19883
19884 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19885 {
19886         if (flags & NDR_IN) {
19887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19888                 if (r->in.server) {
19889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19891                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19892                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19893                 }
19894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19895                 if (r->in.environment) {
19896                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19899                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19900                 }
19901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19903                 if (r->in.buffer) {
19904                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19905                 }
19906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19907         }
19908         if (flags & NDR_OUT) {
19909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19910                 if (r->out.info) {
19911                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19912                 }
19913                 if (r->out.needed == NULL) {
19914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19915                 }
19916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19917                 if (r->out.count == NULL) {
19918                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19919                 }
19920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19922         }
19923         return NDR_ERR_SUCCESS;
19924 }
19925
19926 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19927 {
19928         uint32_t _ptr_server;
19929         uint32_t _ptr_environment;
19930         uint32_t _ptr_buffer;
19931         uint32_t _ptr_info;
19932         TALLOC_CTX *_mem_save_server_0;
19933         TALLOC_CTX *_mem_save_environment_0;
19934         TALLOC_CTX *_mem_save_buffer_0;
19935         TALLOC_CTX *_mem_save_info_0;
19936         TALLOC_CTX *_mem_save_needed_0;
19937         TALLOC_CTX *_mem_save_count_0;
19938         if (flags & NDR_IN) {
19939                 ZERO_STRUCT(r->out);
19940
19941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19942                 if (_ptr_server) {
19943                         NDR_PULL_ALLOC(ndr, r->in.server);
19944                 } else {
19945                         r->in.server = NULL;
19946                 }
19947                 if (r->in.server) {
19948                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19949                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19951                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19952                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19953                                 return 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));
19954                         }
19955                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19956                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19958                 }
19959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19960                 if (_ptr_environment) {
19961                         NDR_PULL_ALLOC(ndr, r->in.environment);
19962                 } else {
19963                         r->in.environment = NULL;
19964                 }
19965                 if (r->in.environment) {
19966                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19967                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19970                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19971                                 return 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));
19972                         }
19973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19976                 }
19977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19978                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19979                 if (_ptr_buffer) {
19980                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19981                 } else {
19982                         r->in.buffer = NULL;
19983                 }
19984                 if (r->in.buffer) {
19985                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19986                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19987                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19989                 }
19990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19991                 NDR_PULL_ALLOC(ndr, r->out.needed);
19992                 ZERO_STRUCTP(r->out.needed);
19993                 NDR_PULL_ALLOC(ndr, r->out.count);
19994                 ZERO_STRUCTP(r->out.count);
19995         }
19996         if (flags & NDR_OUT) {
19997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19998                 if (_ptr_info) {
19999                         NDR_PULL_ALLOC(ndr, r->out.info);
20000                 } else {
20001                         r->out.info = NULL;
20002                 }
20003                 if (r->out.info) {
20004                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20005                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20006                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20008                 }
20009                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20010                         NDR_PULL_ALLOC(ndr, r->out.needed);
20011                 }
20012                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20013                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20016                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20017                         NDR_PULL_ALLOC(ndr, r->out.count);
20018                 }
20019                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20020                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20022                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20023                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20024         }
20025         return NDR_ERR_SUCCESS;
20026 }
20027
20028 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
20029 {
20030         uint32_t cntr_info_0;
20031         if (flags & NDR_IN) {
20032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20034         }
20035         if (flags & NDR_OUT) {
20036                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20037                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20038                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20039                 }
20040                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20041                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20042                 }
20043         }
20044         return NDR_ERR_SUCCESS;
20045 }
20046
20047 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
20048 {
20049         uint32_t cntr_info_0;
20050         TALLOC_CTX *_mem_save_info_0;
20051         if (flags & NDR_IN) {
20052                 ZERO_STRUCT(r->out);
20053
20054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20056         }
20057         if (flags & NDR_OUT) {
20058                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20059                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20060                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20061                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20062                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20063                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20064                 }
20065                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20066                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20067                 }
20068                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20069         }
20070         return NDR_ERR_SUCCESS;
20071 }
20072
20073 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
20074 {
20075         uint32_t cntr_info_2;
20076         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
20077         ndr->depth++;
20078         if (flags & NDR_SET_VALUES) {
20079                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20080         }
20081         if (flags & NDR_IN) {
20082                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
20083                 ndr->depth++;
20084                 ndr_print_ptr(ndr, "server", r->in.server);
20085                 ndr->depth++;
20086                 if (r->in.server) {
20087                         ndr_print_string(ndr, "server", r->in.server);
20088                 }
20089                 ndr->depth--;
20090                 ndr_print_ptr(ndr, "environment", r->in.environment);
20091                 ndr->depth++;
20092                 if (r->in.environment) {
20093                         ndr_print_string(ndr, "environment", r->in.environment);
20094                 }
20095                 ndr->depth--;
20096                 ndr_print_uint32(ndr, "level", r->in.level);
20097                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20098                 ndr->depth++;
20099                 if (r->in.buffer) {
20100                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20101                 }
20102                 ndr->depth--;
20103                 ndr_print_uint32(ndr, "offered", r->in.offered);
20104                 ndr->depth--;
20105         }
20106         if (flags & NDR_OUT) {
20107                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
20108                 ndr->depth++;
20109                 ndr_print_ptr(ndr, "count", r->out.count);
20110                 ndr->depth++;
20111                 ndr_print_uint32(ndr, "count", *r->out.count);
20112                 ndr->depth--;
20113                 ndr_print_ptr(ndr, "info", r->out.info);
20114                 ndr->depth++;
20115                 ndr_print_ptr(ndr, "info", *r->out.info);
20116                 ndr->depth++;
20117                 if (*r->out.info) {
20118                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20119                         ndr->depth++;
20120                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20121                                 char *idx_2=NULL;
20122                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20123                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20124                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20125                                         free(idx_2);
20126                                 }
20127                         }
20128                         ndr->depth--;
20129                 }
20130                 ndr->depth--;
20131                 ndr->depth--;
20132                 ndr_print_ptr(ndr, "needed", r->out.needed);
20133                 ndr->depth++;
20134                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20135                 ndr->depth--;
20136                 ndr_print_WERROR(ndr, "result", r->out.result);
20137                 ndr->depth--;
20138         }
20139         ndr->depth--;
20140 }
20141
20142 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20143 {
20144         if (flags & NDR_IN) {
20145         }
20146         if (flags & NDR_OUT) {
20147                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20148         }
20149         return NDR_ERR_SUCCESS;
20150 }
20151
20152 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20153 {
20154         if (flags & NDR_IN) {
20155         }
20156         if (flags & NDR_OUT) {
20157                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20158         }
20159         return NDR_ERR_SUCCESS;
20160 }
20161
20162 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20163 {
20164         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
20165         ndr->depth++;
20166         if (flags & NDR_SET_VALUES) {
20167                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20168         }
20169         if (flags & NDR_IN) {
20170                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20171                 ndr->depth++;
20172                 ndr->depth--;
20173         }
20174         if (flags & NDR_OUT) {
20175                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20176                 ndr->depth++;
20177                 ndr_print_WERROR(ndr, "result", r->out.result);
20178                 ndr->depth--;
20179         }
20180         ndr->depth--;
20181 }
20182
20183 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20184 {
20185         if (flags & NDR_IN) {
20186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20187                 if (r->in.server) {
20188                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20189                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20190                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20191                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20192                 }
20193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20194                 if (r->in.environment) {
20195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20196                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20197                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20198                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20199                 }
20200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20201                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20202                 if (r->in.buffer) {
20203                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20204                 }
20205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20206         }
20207         if (flags & NDR_OUT) {
20208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20209                 if (r->out.info) {
20210                         {
20211                                 struct ndr_push *_ndr_info;
20212                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20213                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20214                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20215                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20216                         }
20217                 }
20218                 if (r->out.needed == NULL) {
20219                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20220                 }
20221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20222                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20223         }
20224         return NDR_ERR_SUCCESS;
20225 }
20226
20227 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20228 {
20229         uint32_t _ptr_server;
20230         uint32_t _ptr_environment;
20231         uint32_t _ptr_buffer;
20232         uint32_t _ptr_info;
20233         TALLOC_CTX *_mem_save_server_0;
20234         TALLOC_CTX *_mem_save_environment_0;
20235         TALLOC_CTX *_mem_save_buffer_0;
20236         TALLOC_CTX *_mem_save_info_0;
20237         TALLOC_CTX *_mem_save_needed_0;
20238         if (flags & NDR_IN) {
20239                 ZERO_STRUCT(r->out);
20240
20241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20242                 if (_ptr_server) {
20243                         NDR_PULL_ALLOC(ndr, r->in.server);
20244                 } else {
20245                         r->in.server = NULL;
20246                 }
20247                 if (r->in.server) {
20248                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20249                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20252                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20253                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
20254                         }
20255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20258                 }
20259                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20260                 if (_ptr_environment) {
20261                         NDR_PULL_ALLOC(ndr, r->in.environment);
20262                 } else {
20263                         r->in.environment = NULL;
20264                 }
20265                 if (r->in.environment) {
20266                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20267                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20270                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20271                                 return 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));
20272                         }
20273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20276                 }
20277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20279                 if (_ptr_buffer) {
20280                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20281                 } else {
20282                         r->in.buffer = NULL;
20283                 }
20284                 if (r->in.buffer) {
20285                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20286                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20287                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20289                 }
20290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20291                 NDR_PULL_ALLOC(ndr, r->out.needed);
20292                 ZERO_STRUCTP(r->out.needed);
20293         }
20294         if (flags & NDR_OUT) {
20295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20296                 if (_ptr_info) {
20297                         NDR_PULL_ALLOC(ndr, r->out.info);
20298                 } else {
20299                         r->out.info = NULL;
20300                 }
20301                 if (r->out.info) {
20302                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20303                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20304                         {
20305                                 struct ndr_pull *_ndr_info;
20306                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20307                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20308                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20309                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20310                         }
20311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20312                 }
20313                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20314                         NDR_PULL_ALLOC(ndr, r->out.needed);
20315                 }
20316                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20317                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20319                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20320                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20321         }
20322         return NDR_ERR_SUCCESS;
20323 }
20324
20325 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20326 {
20327         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20328         ndr->depth++;
20329         if (flags & NDR_SET_VALUES) {
20330                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20331         }
20332         if (flags & NDR_IN) {
20333                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20334                 ndr->depth++;
20335                 ndr_print_ptr(ndr, "server", r->in.server);
20336                 ndr->depth++;
20337                 if (r->in.server) {
20338                         ndr_print_string(ndr, "server", r->in.server);
20339                 }
20340                 ndr->depth--;
20341                 ndr_print_ptr(ndr, "environment", r->in.environment);
20342                 ndr->depth++;
20343                 if (r->in.environment) {
20344                         ndr_print_string(ndr, "environment", r->in.environment);
20345                 }
20346                 ndr->depth--;
20347                 ndr_print_uint32(ndr, "level", r->in.level);
20348                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20349                 ndr->depth++;
20350                 if (r->in.buffer) {
20351                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20352                 }
20353                 ndr->depth--;
20354                 ndr_print_uint32(ndr, "offered", r->in.offered);
20355                 ndr->depth--;
20356         }
20357         if (flags & NDR_OUT) {
20358                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20359                 ndr->depth++;
20360                 ndr_print_ptr(ndr, "info", r->out.info);
20361                 ndr->depth++;
20362                 if (r->out.info) {
20363                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20364                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20365                 }
20366                 ndr->depth--;
20367                 ndr_print_ptr(ndr, "needed", r->out.needed);
20368                 ndr->depth++;
20369                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20370                 ndr->depth--;
20371                 ndr_print_WERROR(ndr, "result", r->out.result);
20372                 ndr->depth--;
20373         }
20374         ndr->depth--;
20375 }
20376
20377 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20378 {
20379         if (flags & NDR_IN) {
20380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20381                 if (r->in.server) {
20382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20385                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20386                 }
20387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20390                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20394                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20395         }
20396         if (flags & NDR_OUT) {
20397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20398         }
20399         return NDR_ERR_SUCCESS;
20400 }
20401
20402 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20403 {
20404         uint32_t _ptr_server;
20405         TALLOC_CTX *_mem_save_server_0;
20406         if (flags & NDR_IN) {
20407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20408                 if (_ptr_server) {
20409                         NDR_PULL_ALLOC(ndr, r->in.server);
20410                 } else {
20411                         r->in.server = NULL;
20412                 }
20413                 if (r->in.server) {
20414                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20415                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20416                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20417                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20418                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20419                                 return 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));
20420                         }
20421                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20422                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20424                 }
20425                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20426                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20427                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20428                         return 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));
20429                 }
20430                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20431                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20432                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20433                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20434                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20435                         return 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));
20436                 }
20437                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20438                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20439         }
20440         if (flags & NDR_OUT) {
20441                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20442         }
20443         return NDR_ERR_SUCCESS;
20444 }
20445
20446 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20447 {
20448         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20449         ndr->depth++;
20450         if (flags & NDR_SET_VALUES) {
20451                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20452         }
20453         if (flags & NDR_IN) {
20454                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20455                 ndr->depth++;
20456                 ndr_print_ptr(ndr, "server", r->in.server);
20457                 ndr->depth++;
20458                 if (r->in.server) {
20459                         ndr_print_string(ndr, "server", r->in.server);
20460                 }
20461                 ndr->depth--;
20462                 ndr_print_string(ndr, "architecture", r->in.architecture);
20463                 ndr_print_string(ndr, "driver", r->in.driver);
20464                 ndr->depth--;
20465         }
20466         if (flags & NDR_OUT) {
20467                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20468                 ndr->depth++;
20469                 ndr_print_WERROR(ndr, "result", r->out.result);
20470                 ndr->depth--;
20471         }
20472         ndr->depth--;
20473 }
20474
20475 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20476 {
20477         if (flags & NDR_IN) {
20478                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20479                 if (r->in.server) {
20480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20483                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20484                 }
20485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20488                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20492                 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));
20493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20496                 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));
20497         }
20498         if (flags & NDR_OUT) {
20499                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20500         }
20501         return NDR_ERR_SUCCESS;
20502 }
20503
20504 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20505 {
20506         uint32_t _ptr_server;
20507         TALLOC_CTX *_mem_save_server_0;
20508         if (flags & NDR_IN) {
20509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20510                 if (_ptr_server) {
20511                         NDR_PULL_ALLOC(ndr, r->in.server);
20512                 } else {
20513                         r->in.server = NULL;
20514                 }
20515                 if (r->in.server) {
20516                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20517                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20518                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20519                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20520                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20521                                 return 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));
20522                         }
20523                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20524                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20526                 }
20527                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20528                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20529                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20530                         return 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));
20531                 }
20532                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20533                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20534                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20535                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20536                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20537                         return 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));
20538                 }
20539                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20540                 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));
20541                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20542                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20543                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20544                         return 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));
20545                 }
20546                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20547                 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));
20548         }
20549         if (flags & NDR_OUT) {
20550                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20551         }
20552         return NDR_ERR_SUCCESS;
20553 }
20554
20555 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20556 {
20557         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20558         ndr->depth++;
20559         if (flags & NDR_SET_VALUES) {
20560                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20561         }
20562         if (flags & NDR_IN) {
20563                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20564                 ndr->depth++;
20565                 ndr_print_ptr(ndr, "server", r->in.server);
20566                 ndr->depth++;
20567                 if (r->in.server) {
20568                         ndr_print_string(ndr, "server", r->in.server);
20569                 }
20570                 ndr->depth--;
20571                 ndr_print_string(ndr, "architecture", r->in.architecture);
20572                 ndr_print_string(ndr, "path_name", r->in.path_name);
20573                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20574                 ndr->depth--;
20575         }
20576         if (flags & NDR_OUT) {
20577                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20578                 ndr->depth++;
20579                 ndr_print_WERROR(ndr, "result", r->out.result);
20580                 ndr->depth--;
20581         }
20582         ndr->depth--;
20583 }
20584
20585 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20586 {
20587         if (flags & NDR_IN) {
20588                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20589                 if (r->in.servername) {
20590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20591                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20592                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20593                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20594                 }
20595                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20596                 if (r->in.environment) {
20597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20599                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20600                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20601                 }
20602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20604                 if (r->in.buffer) {
20605                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20606                 }
20607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20608         }
20609         if (flags & NDR_OUT) {
20610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20611                 if (r->out.info) {
20612                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20613                 }
20614                 if (r->out.needed == NULL) {
20615                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20616                 }
20617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20618                 if (r->out.count == NULL) {
20619                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20620                 }
20621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20622                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20623         }
20624         return NDR_ERR_SUCCESS;
20625 }
20626
20627 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20628 {
20629         uint32_t _ptr_servername;
20630         uint32_t _ptr_environment;
20631         uint32_t _ptr_buffer;
20632         uint32_t _ptr_info;
20633         TALLOC_CTX *_mem_save_servername_0;
20634         TALLOC_CTX *_mem_save_environment_0;
20635         TALLOC_CTX *_mem_save_buffer_0;
20636         TALLOC_CTX *_mem_save_info_0;
20637         TALLOC_CTX *_mem_save_needed_0;
20638         TALLOC_CTX *_mem_save_count_0;
20639         if (flags & NDR_IN) {
20640                 ZERO_STRUCT(r->out);
20641
20642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20643                 if (_ptr_servername) {
20644                         NDR_PULL_ALLOC(ndr, r->in.servername);
20645                 } else {
20646                         r->in.servername = NULL;
20647                 }
20648                 if (r->in.servername) {
20649                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20650                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20653                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20654                                 return 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));
20655                         }
20656                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20657                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20659                 }
20660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20661                 if (_ptr_environment) {
20662                         NDR_PULL_ALLOC(ndr, r->in.environment);
20663                 } else {
20664                         r->in.environment = NULL;
20665                 }
20666                 if (r->in.environment) {
20667                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20668                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20669                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20670                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20671                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20672                                 return 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));
20673                         }
20674                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20675                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20677                 }
20678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20679                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20680                 if (_ptr_buffer) {
20681                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20682                 } else {
20683                         r->in.buffer = NULL;
20684                 }
20685                 if (r->in.buffer) {
20686                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20687                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20688                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20689                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20690                 }
20691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20692                 NDR_PULL_ALLOC(ndr, r->out.needed);
20693                 ZERO_STRUCTP(r->out.needed);
20694                 NDR_PULL_ALLOC(ndr, r->out.count);
20695                 ZERO_STRUCTP(r->out.count);
20696         }
20697         if (flags & NDR_OUT) {
20698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20699                 if (_ptr_info) {
20700                         NDR_PULL_ALLOC(ndr, r->out.info);
20701                 } else {
20702                         r->out.info = NULL;
20703                 }
20704                 if (r->out.info) {
20705                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20706                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20707                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20709                 }
20710                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20711                         NDR_PULL_ALLOC(ndr, r->out.needed);
20712                 }
20713                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20714                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20718                         NDR_PULL_ALLOC(ndr, r->out.count);
20719                 }
20720                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20721                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20724                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20725         }
20726         return NDR_ERR_SUCCESS;
20727 }
20728
20729 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20730 {
20731         uint32_t cntr_info_0;
20732         if (flags & NDR_IN) {
20733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20735         }
20736         if (flags & NDR_OUT) {
20737                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20738                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20739                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20740                 }
20741                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20742                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20743                 }
20744         }
20745         return NDR_ERR_SUCCESS;
20746 }
20747
20748 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20749 {
20750         uint32_t cntr_info_0;
20751         TALLOC_CTX *_mem_save_info_0;
20752         if (flags & NDR_IN) {
20753                 ZERO_STRUCT(r->out);
20754
20755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20757         }
20758         if (flags & NDR_OUT) {
20759                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20760                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20761                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20762                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20763                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20764                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20765                 }
20766                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20767                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20768                 }
20769                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20770         }
20771         return NDR_ERR_SUCCESS;
20772 }
20773
20774 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20775 {
20776         uint32_t cntr_info_2;
20777         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20778         ndr->depth++;
20779         if (flags & NDR_SET_VALUES) {
20780                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20781         }
20782         if (flags & NDR_IN) {
20783                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20784                 ndr->depth++;
20785                 ndr_print_ptr(ndr, "servername", r->in.servername);
20786                 ndr->depth++;
20787                 if (r->in.servername) {
20788                         ndr_print_string(ndr, "servername", r->in.servername);
20789                 }
20790                 ndr->depth--;
20791                 ndr_print_ptr(ndr, "environment", r->in.environment);
20792                 ndr->depth++;
20793                 if (r->in.environment) {
20794                         ndr_print_string(ndr, "environment", r->in.environment);
20795                 }
20796                 ndr->depth--;
20797                 ndr_print_uint32(ndr, "level", r->in.level);
20798                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20799                 ndr->depth++;
20800                 if (r->in.buffer) {
20801                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20802                 }
20803                 ndr->depth--;
20804                 ndr_print_uint32(ndr, "offered", r->in.offered);
20805                 ndr->depth--;
20806         }
20807         if (flags & NDR_OUT) {
20808                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20809                 ndr->depth++;
20810                 ndr_print_ptr(ndr, "count", r->out.count);
20811                 ndr->depth++;
20812                 ndr_print_uint32(ndr, "count", *r->out.count);
20813                 ndr->depth--;
20814                 ndr_print_ptr(ndr, "info", r->out.info);
20815                 ndr->depth++;
20816                 ndr_print_ptr(ndr, "info", *r->out.info);
20817                 ndr->depth++;
20818                 if (*r->out.info) {
20819                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20820                         ndr->depth++;
20821                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20822                                 char *idx_2=NULL;
20823                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20824                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20825                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20826                                         free(idx_2);
20827                                 }
20828                         }
20829                         ndr->depth--;
20830                 }
20831                 ndr->depth--;
20832                 ndr->depth--;
20833                 ndr_print_ptr(ndr, "needed", r->out.needed);
20834                 ndr->depth++;
20835                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20836                 ndr->depth--;
20837                 ndr_print_WERROR(ndr, "result", r->out.result);
20838                 ndr->depth--;
20839         }
20840         ndr->depth--;
20841 }
20842
20843 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20844 {
20845         if (flags & NDR_IN) {
20846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20847                 if (r->in.server) {
20848                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20849                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20851                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20852                 }
20853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20854                 if (r->in.environment) {
20855                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20858                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20859                 }
20860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20861                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20862                 if (r->in.buffer) {
20863                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20864                 }
20865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20866         }
20867         if (flags & NDR_OUT) {
20868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20869                 if (r->out.info) {
20870                         {
20871                                 struct ndr_push *_ndr_info;
20872                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20873                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20874                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20875                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20876                         }
20877                 }
20878                 if (r->out.needed == NULL) {
20879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20880                 }
20881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20882                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20883         }
20884         return NDR_ERR_SUCCESS;
20885 }
20886
20887 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20888 {
20889         uint32_t _ptr_server;
20890         uint32_t _ptr_environment;
20891         uint32_t _ptr_buffer;
20892         uint32_t _ptr_info;
20893         TALLOC_CTX *_mem_save_server_0;
20894         TALLOC_CTX *_mem_save_environment_0;
20895         TALLOC_CTX *_mem_save_buffer_0;
20896         TALLOC_CTX *_mem_save_info_0;
20897         TALLOC_CTX *_mem_save_needed_0;
20898         if (flags & NDR_IN) {
20899                 ZERO_STRUCT(r->out);
20900
20901                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20902                 if (_ptr_server) {
20903                         NDR_PULL_ALLOC(ndr, r->in.server);
20904                 } else {
20905                         r->in.server = NULL;
20906                 }
20907                 if (r->in.server) {
20908                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20909                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20910                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20911                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20912                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20913                                 return 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));
20914                         }
20915                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20916                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20918                 }
20919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20920                 if (_ptr_environment) {
20921                         NDR_PULL_ALLOC(ndr, r->in.environment);
20922                 } else {
20923                         r->in.environment = NULL;
20924                 }
20925                 if (r->in.environment) {
20926                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20927                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20930                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20931                                 return 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));
20932                         }
20933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20936                 }
20937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20939                 if (_ptr_buffer) {
20940                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20941                 } else {
20942                         r->in.buffer = NULL;
20943                 }
20944                 if (r->in.buffer) {
20945                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20946                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20947                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20949                 }
20950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20951                 NDR_PULL_ALLOC(ndr, r->out.needed);
20952                 ZERO_STRUCTP(r->out.needed);
20953         }
20954         if (flags & NDR_OUT) {
20955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20956                 if (_ptr_info) {
20957                         NDR_PULL_ALLOC(ndr, r->out.info);
20958                 } else {
20959                         r->out.info = NULL;
20960                 }
20961                 if (r->out.info) {
20962                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20963                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20964                         {
20965                                 struct ndr_pull *_ndr_info;
20966                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20967                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20968                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20969                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20970                         }
20971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20972                 }
20973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20974                         NDR_PULL_ALLOC(ndr, r->out.needed);
20975                 }
20976                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20977                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20980                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20981         }
20982         return NDR_ERR_SUCCESS;
20983 }
20984
20985 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20986 {
20987         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20988         ndr->depth++;
20989         if (flags & NDR_SET_VALUES) {
20990                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20991         }
20992         if (flags & NDR_IN) {
20993                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20994                 ndr->depth++;
20995                 ndr_print_ptr(ndr, "server", r->in.server);
20996                 ndr->depth++;
20997                 if (r->in.server) {
20998                         ndr_print_string(ndr, "server", r->in.server);
20999                 }
21000                 ndr->depth--;
21001                 ndr_print_ptr(ndr, "environment", r->in.environment);
21002                 ndr->depth++;
21003                 if (r->in.environment) {
21004                         ndr_print_string(ndr, "environment", r->in.environment);
21005                 }
21006                 ndr->depth--;
21007                 ndr_print_uint32(ndr, "level", r->in.level);
21008                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21009                 ndr->depth++;
21010                 if (r->in.buffer) {
21011                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21012                 }
21013                 ndr->depth--;
21014                 ndr_print_uint32(ndr, "offered", r->in.offered);
21015                 ndr->depth--;
21016         }
21017         if (flags & NDR_OUT) {
21018                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
21019                 ndr->depth++;
21020                 ndr_print_ptr(ndr, "info", r->out.info);
21021                 ndr->depth++;
21022                 if (r->out.info) {
21023                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21024                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
21025                 }
21026                 ndr->depth--;
21027                 ndr_print_ptr(ndr, "needed", r->out.needed);
21028                 ndr->depth++;
21029                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21030                 ndr->depth--;
21031                 ndr_print_WERROR(ndr, "result", r->out.result);
21032                 ndr->depth--;
21033         }
21034         ndr->depth--;
21035 }
21036
21037 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
21038 {
21039         if (flags & NDR_IN) {
21040                 if (r->in.handle == NULL) {
21041                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21042                 }
21043                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21045                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21046                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21047         }
21048         if (flags & NDR_OUT) {
21049                 if (r->out.job_id == NULL) {
21050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21051                 }
21052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
21053                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21054         }
21055         return NDR_ERR_SUCCESS;
21056 }
21057
21058 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
21059 {
21060         TALLOC_CTX *_mem_save_handle_0;
21061         TALLOC_CTX *_mem_save_job_id_0;
21062         if (flags & NDR_IN) {
21063                 ZERO_STRUCT(r->out);
21064
21065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21066                         NDR_PULL_ALLOC(ndr, r->in.handle);
21067                 }
21068                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21069                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21070                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21073                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21074                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21075                 NDR_PULL_ALLOC(ndr, r->out.job_id);
21076                 ZERO_STRUCTP(r->out.job_id);
21077         }
21078         if (flags & NDR_OUT) {
21079                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21080                         NDR_PULL_ALLOC(ndr, r->out.job_id);
21081                 }
21082                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
21083                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
21084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
21085                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
21086                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21087         }
21088         return NDR_ERR_SUCCESS;
21089 }
21090
21091 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
21092 {
21093         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
21094         ndr->depth++;
21095         if (flags & NDR_SET_VALUES) {
21096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21097         }
21098         if (flags & NDR_IN) {
21099                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
21100                 ndr->depth++;
21101                 ndr_print_ptr(ndr, "handle", r->in.handle);
21102                 ndr->depth++;
21103                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21104                 ndr->depth--;
21105                 ndr_print_uint32(ndr, "level", r->in.level);
21106                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21107                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
21108                 ndr->depth--;
21109         }
21110         if (flags & NDR_OUT) {
21111                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
21112                 ndr->depth++;
21113                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
21114                 ndr->depth++;
21115                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
21116                 ndr->depth--;
21117                 ndr_print_WERROR(ndr, "result", r->out.result);
21118                 ndr->depth--;
21119         }
21120         ndr->depth--;
21121 }
21122
21123 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
21124 {
21125         if (flags & NDR_IN) {
21126                 if (r->in.handle == NULL) {
21127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21128                 }
21129                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21130         }
21131         if (flags & NDR_OUT) {
21132                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21133         }
21134         return NDR_ERR_SUCCESS;
21135 }
21136
21137 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
21138 {
21139         TALLOC_CTX *_mem_save_handle_0;
21140         if (flags & NDR_IN) {
21141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21142                         NDR_PULL_ALLOC(ndr, r->in.handle);
21143                 }
21144                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21145                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21146                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21148         }
21149         if (flags & NDR_OUT) {
21150                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21151         }
21152         return NDR_ERR_SUCCESS;
21153 }
21154
21155 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
21156 {
21157         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
21158         ndr->depth++;
21159         if (flags & NDR_SET_VALUES) {
21160                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21161         }
21162         if (flags & NDR_IN) {
21163                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
21164                 ndr->depth++;
21165                 ndr_print_ptr(ndr, "handle", r->in.handle);
21166                 ndr->depth++;
21167                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21168                 ndr->depth--;
21169                 ndr->depth--;
21170         }
21171         if (flags & NDR_OUT) {
21172                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21173                 ndr->depth++;
21174                 ndr_print_WERROR(ndr, "result", r->out.result);
21175                 ndr->depth--;
21176         }
21177         ndr->depth--;
21178 }
21179
21180 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21181 {
21182         if (flags & NDR_IN) {
21183                 if (r->in.handle == NULL) {
21184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21185                 }
21186                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21187                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21189         }
21190         if (flags & NDR_OUT) {
21191                 if (r->out.num_written == NULL) {
21192                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21193                 }
21194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21195                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21196         }
21197         return NDR_ERR_SUCCESS;
21198 }
21199
21200 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21201 {
21202         TALLOC_CTX *_mem_save_handle_0;
21203         TALLOC_CTX *_mem_save_num_written_0;
21204         if (flags & NDR_IN) {
21205                 ZERO_STRUCT(r->out);
21206
21207                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21208                         NDR_PULL_ALLOC(ndr, r->in.handle);
21209                 }
21210                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21211                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21212                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21214                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21216                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21217                 ZERO_STRUCTP(r->out.num_written);
21218         }
21219         if (flags & NDR_OUT) {
21220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21221                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21222                 }
21223                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21224                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21227                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21228         }
21229         return NDR_ERR_SUCCESS;
21230 }
21231
21232 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21233 {
21234         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21235         ndr->depth++;
21236         if (flags & NDR_SET_VALUES) {
21237                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21238         }
21239         if (flags & NDR_IN) {
21240                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21241                 ndr->depth++;
21242                 ndr_print_ptr(ndr, "handle", r->in.handle);
21243                 ndr->depth++;
21244                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21245                 ndr->depth--;
21246                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21247                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21248                 ndr->depth--;
21249         }
21250         if (flags & NDR_OUT) {
21251                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21252                 ndr->depth++;
21253                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21254                 ndr->depth++;
21255                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21256                 ndr->depth--;
21257                 ndr_print_WERROR(ndr, "result", r->out.result);
21258                 ndr->depth--;
21259         }
21260         ndr->depth--;
21261 }
21262
21263 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21264 {
21265         if (flags & NDR_IN) {
21266                 if (r->in.handle == NULL) {
21267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21268                 }
21269                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21270         }
21271         if (flags & NDR_OUT) {
21272                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21273         }
21274         return NDR_ERR_SUCCESS;
21275 }
21276
21277 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21278 {
21279         TALLOC_CTX *_mem_save_handle_0;
21280         if (flags & NDR_IN) {
21281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21282                         NDR_PULL_ALLOC(ndr, r->in.handle);
21283                 }
21284                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21285                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21286                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21287                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21288         }
21289         if (flags & NDR_OUT) {
21290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21291         }
21292         return NDR_ERR_SUCCESS;
21293 }
21294
21295 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21296 {
21297         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21298         ndr->depth++;
21299         if (flags & NDR_SET_VALUES) {
21300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21301         }
21302         if (flags & NDR_IN) {
21303                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21304                 ndr->depth++;
21305                 ndr_print_ptr(ndr, "handle", r->in.handle);
21306                 ndr->depth++;
21307                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21308                 ndr->depth--;
21309                 ndr->depth--;
21310         }
21311         if (flags & NDR_OUT) {
21312                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
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_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21321 {
21322         if (flags & NDR_IN) {
21323                 if (r->in.handle == NULL) {
21324                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21325                 }
21326                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21327         }
21328         if (flags & NDR_OUT) {
21329                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21330         }
21331         return NDR_ERR_SUCCESS;
21332 }
21333
21334 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21335 {
21336         TALLOC_CTX *_mem_save_handle_0;
21337         if (flags & NDR_IN) {
21338                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21339                         NDR_PULL_ALLOC(ndr, r->in.handle);
21340                 }
21341                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21342                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21343                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21344                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21345         }
21346         if (flags & NDR_OUT) {
21347                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21348         }
21349         return NDR_ERR_SUCCESS;
21350 }
21351
21352 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21353 {
21354         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21355         ndr->depth++;
21356         if (flags & NDR_SET_VALUES) {
21357                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21358         }
21359         if (flags & NDR_IN) {
21360                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21361                 ndr->depth++;
21362                 ndr_print_ptr(ndr, "handle", r->in.handle);
21363                 ndr->depth++;
21364                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21365                 ndr->depth--;
21366                 ndr->depth--;
21367         }
21368         if (flags & NDR_OUT) {
21369                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21370                 ndr->depth++;
21371                 ndr_print_WERROR(ndr, "result", r->out.result);
21372                 ndr->depth--;
21373         }
21374         ndr->depth--;
21375 }
21376
21377 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21378 {
21379         if (flags & NDR_IN) {
21380                 if (r->in.handle == NULL) {
21381                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21382                 }
21383                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21385         }
21386         if (flags & NDR_OUT) {
21387                 if (r->out.data == NULL) {
21388                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21389                 }
21390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21391                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21392                 if (r->out._data_size == NULL) {
21393                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21394                 }
21395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21397         }
21398         return NDR_ERR_SUCCESS;
21399 }
21400
21401 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21402 {
21403         TALLOC_CTX *_mem_save_handle_0;
21404         TALLOC_CTX *_mem_save__data_size_0;
21405         if (flags & NDR_IN) {
21406                 ZERO_STRUCT(r->out);
21407
21408                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21409                         NDR_PULL_ALLOC(ndr, r->in.handle);
21410                 }
21411                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21412                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21413                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21414                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21416                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21417                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21418                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21419                 ZERO_STRUCTP(r->out._data_size);
21420         }
21421         if (flags & NDR_OUT) {
21422                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21423                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21424                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21425                 }
21426                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21427                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21428                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21429                 }
21430                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21431                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21434                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21435                 if (r->out.data) {
21436                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21437                 }
21438         }
21439         return NDR_ERR_SUCCESS;
21440 }
21441
21442 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21443 {
21444         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21445         ndr->depth++;
21446         if (flags & NDR_SET_VALUES) {
21447                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21448         }
21449         if (flags & NDR_IN) {
21450                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21451                 ndr->depth++;
21452                 ndr_print_ptr(ndr, "handle", r->in.handle);
21453                 ndr->depth++;
21454                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21455                 ndr->depth--;
21456                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21457                 ndr->depth--;
21458         }
21459         if (flags & NDR_OUT) {
21460                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21461                 ndr->depth++;
21462                 ndr_print_ptr(ndr, "data", r->out.data);
21463                 ndr->depth++;
21464                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21465                 ndr->depth--;
21466                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21467                 ndr->depth++;
21468                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21469                 ndr->depth--;
21470                 ndr_print_WERROR(ndr, "result", r->out.result);
21471                 ndr->depth--;
21472         }
21473         ndr->depth--;
21474 }
21475
21476 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21477 {
21478         if (flags & NDR_IN) {
21479                 if (r->in.handle == NULL) {
21480                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21481                 }
21482                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21483         }
21484         if (flags & NDR_OUT) {
21485                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21486         }
21487         return NDR_ERR_SUCCESS;
21488 }
21489
21490 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21491 {
21492         TALLOC_CTX *_mem_save_handle_0;
21493         if (flags & NDR_IN) {
21494                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21495                         NDR_PULL_ALLOC(ndr, r->in.handle);
21496                 }
21497                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21498                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21499                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21501         }
21502         if (flags & NDR_OUT) {
21503                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21504         }
21505         return NDR_ERR_SUCCESS;
21506 }
21507
21508 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21509 {
21510         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21511         ndr->depth++;
21512         if (flags & NDR_SET_VALUES) {
21513                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21514         }
21515         if (flags & NDR_IN) {
21516                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21517                 ndr->depth++;
21518                 ndr_print_ptr(ndr, "handle", r->in.handle);
21519                 ndr->depth++;
21520                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21521                 ndr->depth--;
21522                 ndr->depth--;
21523         }
21524         if (flags & NDR_OUT) {
21525                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21526                 ndr->depth++;
21527                 ndr_print_WERROR(ndr, "result", r->out.result);
21528                 ndr->depth--;
21529         }
21530         ndr->depth--;
21531 }
21532
21533 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21534 {
21535         if (flags & NDR_IN) {
21536                 if (r->in.handle == NULL) {
21537                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21538                 }
21539                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21541                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21542                 if (r->in.buffer) {
21543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21544                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21545                 }
21546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21547         }
21548         if (flags & NDR_OUT) {
21549                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21550                 if (r->out.buffer) {
21551                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21552                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21553                 }
21554                 if (r->out.needed == NULL) {
21555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21556                 }
21557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21558                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21559         }
21560         return NDR_ERR_SUCCESS;
21561 }
21562
21563 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21564 {
21565         uint32_t _ptr_buffer;
21566         TALLOC_CTX *_mem_save_handle_0;
21567         TALLOC_CTX *_mem_save_buffer_0;
21568         TALLOC_CTX *_mem_save_needed_0;
21569         if (flags & NDR_IN) {
21570                 ZERO_STRUCT(r->out);
21571
21572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21573                         NDR_PULL_ALLOC(ndr, r->in.handle);
21574                 }
21575                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21576                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21577                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21581                 if (_ptr_buffer) {
21582                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21583                 } else {
21584                         r->in.buffer = NULL;
21585                 }
21586                 if (r->in.buffer) {
21587                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21588                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21589                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21590                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21591                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21592                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21593                 }
21594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21595                 NDR_PULL_ALLOC(ndr, r->out.needed);
21596                 ZERO_STRUCTP(r->out.needed);
21597                 if (r->in.buffer) {
21598                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21599                 }
21600         }
21601         if (flags & NDR_OUT) {
21602                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21603                 if (_ptr_buffer) {
21604                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21605                 } else {
21606                         r->out.buffer = NULL;
21607                 }
21608                 if (r->out.buffer) {
21609                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21610                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21611                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21612                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21613                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21615                 }
21616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21617                         NDR_PULL_ALLOC(ndr, r->out.needed);
21618                 }
21619                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21623                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21624                 if (r->out.buffer) {
21625                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21626                 }
21627         }
21628         return NDR_ERR_SUCCESS;
21629 }
21630
21631 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21632 {
21633         ndr_print_struct(ndr, name, "spoolss_AddJob");
21634         ndr->depth++;
21635         if (flags & NDR_SET_VALUES) {
21636                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21637         }
21638         if (flags & NDR_IN) {
21639                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21640                 ndr->depth++;
21641                 ndr_print_ptr(ndr, "handle", r->in.handle);
21642                 ndr->depth++;
21643                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21644                 ndr->depth--;
21645                 ndr_print_uint32(ndr, "level", r->in.level);
21646                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21647                 ndr->depth++;
21648                 if (r->in.buffer) {
21649                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21650                 }
21651                 ndr->depth--;
21652                 ndr_print_uint32(ndr, "offered", r->in.offered);
21653                 ndr->depth--;
21654         }
21655         if (flags & NDR_OUT) {
21656                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21657                 ndr->depth++;
21658                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21659                 ndr->depth++;
21660                 if (r->out.buffer) {
21661                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21662                 }
21663                 ndr->depth--;
21664                 ndr_print_ptr(ndr, "needed", r->out.needed);
21665                 ndr->depth++;
21666                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21667                 ndr->depth--;
21668                 ndr_print_WERROR(ndr, "result", r->out.result);
21669                 ndr->depth--;
21670         }
21671         ndr->depth--;
21672 }
21673
21674 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21675 {
21676         if (flags & NDR_IN) {
21677                 if (r->in.handle == NULL) {
21678                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21679                 }
21680                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21682         }
21683         if (flags & NDR_OUT) {
21684                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21685         }
21686         return NDR_ERR_SUCCESS;
21687 }
21688
21689 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21690 {
21691         TALLOC_CTX *_mem_save_handle_0;
21692         if (flags & NDR_IN) {
21693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21694                         NDR_PULL_ALLOC(ndr, r->in.handle);
21695                 }
21696                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21697                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21698                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21701         }
21702         if (flags & NDR_OUT) {
21703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21704         }
21705         return NDR_ERR_SUCCESS;
21706 }
21707
21708 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21709 {
21710         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21711         ndr->depth++;
21712         if (flags & NDR_SET_VALUES) {
21713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21714         }
21715         if (flags & NDR_IN) {
21716                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21717                 ndr->depth++;
21718                 ndr_print_ptr(ndr, "handle", r->in.handle);
21719                 ndr->depth++;
21720                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21721                 ndr->depth--;
21722                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21723                 ndr->depth--;
21724         }
21725         if (flags & NDR_OUT) {
21726                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21727                 ndr->depth++;
21728                 ndr_print_WERROR(ndr, "result", r->out.result);
21729                 ndr->depth--;
21730         }
21731         ndr->depth--;
21732 }
21733
21734 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21735 {
21736         if (flags & NDR_IN) {
21737                 if (r->in.handle == NULL) {
21738                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21739                 }
21740                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21744                 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));
21745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21746         }
21747         if (flags & NDR_OUT) {
21748                 if (r->out.type == NULL) {
21749                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21750                 }
21751                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
21752                 if (r->out.data == NULL) {
21753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21754                 }
21755                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
21756                 if (r->out.needed == NULL) {
21757                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21758                 }
21759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21760                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21761         }
21762         return NDR_ERR_SUCCESS;
21763 }
21764
21765 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21766 {
21767         TALLOC_CTX *_mem_save_handle_0;
21768         TALLOC_CTX *_mem_save_type_0;
21769         TALLOC_CTX *_mem_save_data_0;
21770         TALLOC_CTX *_mem_save_needed_0;
21771         if (flags & NDR_IN) {
21772                 ZERO_STRUCT(r->out);
21773
21774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21775                         NDR_PULL_ALLOC(ndr, r->in.handle);
21776                 }
21777                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21778                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21779                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21780                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21781                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21782                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21783                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21784                         return 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));
21785                 }
21786                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21787                 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));
21788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21789                 NDR_PULL_ALLOC(ndr, r->out.type);
21790                 ZERO_STRUCTP(r->out.type);
21791                 NDR_PULL_ALLOC(ndr, r->out.data);
21792                 ZERO_STRUCTP(r->out.data);
21793                 NDR_PULL_ALLOC(ndr, r->out.needed);
21794                 ZERO_STRUCTP(r->out.needed);
21795         }
21796         if (flags & NDR_OUT) {
21797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21798                         NDR_PULL_ALLOC(ndr, r->out.type);
21799                 }
21800                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21801                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21802                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
21803                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21804                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21805                         NDR_PULL_ALLOC(ndr, r->out.data);
21806                 }
21807                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21808                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21809                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21810                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21811                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21812                         NDR_PULL_ALLOC(ndr, r->out.needed);
21813                 }
21814                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21815                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21817                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21818                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21819         }
21820         return NDR_ERR_SUCCESS;
21821 }
21822
21823 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21824 {
21825         if (flags & NDR_IN) {
21826                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21827         }
21828         if (flags & NDR_OUT) {
21829                 if (r->out.data == NULL) {
21830                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21831                 }
21832                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
21833                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21834         }
21835         return NDR_ERR_SUCCESS;
21836 }
21837
21838 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21839 {
21840         TALLOC_CTX *_mem_save_data_0;
21841         if (flags & NDR_IN) {
21842                 ZERO_STRUCT(r->out);
21843
21844                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
21845                 NDR_PULL_ALLOC(ndr, r->out.data);
21846                 ZERO_STRUCTP(r->out.data);
21847         }
21848         if (flags & NDR_OUT) {
21849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21850                         NDR_PULL_ALLOC(ndr, r->out.data);
21851                 }
21852                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21853                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21854                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
21855                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21856                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21857         }
21858         return NDR_ERR_SUCCESS;
21859 }
21860
21861 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21862 {
21863         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21864         ndr->depth++;
21865         if (flags & NDR_SET_VALUES) {
21866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21867         }
21868         if (flags & NDR_IN) {
21869                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21870                 ndr->depth++;
21871                 ndr_print_ptr(ndr, "handle", r->in.handle);
21872                 ndr->depth++;
21873                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21874                 ndr->depth--;
21875                 ndr_print_string(ndr, "value_name", r->in.value_name);
21876                 ndr_print_uint32(ndr, "offered", r->in.offered);
21877                 ndr->depth--;
21878         }
21879         if (flags & NDR_OUT) {
21880                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21881                 ndr->depth++;
21882                 ndr_print_ptr(ndr, "type", r->out.type);
21883                 ndr->depth++;
21884                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
21885                 ndr->depth--;
21886                 ndr_print_ptr(ndr, "data", r->out.data);
21887                 ndr->depth++;
21888                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
21889                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
21890                 ndr->depth--;
21891                 ndr_print_ptr(ndr, "needed", r->out.needed);
21892                 ndr->depth++;
21893                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21894                 ndr->depth--;
21895                 ndr_print_WERROR(ndr, "result", r->out.result);
21896                 ndr->depth--;
21897         }
21898         ndr->depth--;
21899 }
21900
21901 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21902 {
21903         if (flags & NDR_IN) {
21904                 if (r->in.handle == NULL) {
21905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21906                 }
21907                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21911                 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));
21912                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21913                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21915         }
21916         if (flags & NDR_OUT) {
21917                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21918         }
21919         return NDR_ERR_SUCCESS;
21920 }
21921
21922 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21923 {
21924         if (flags & NDR_IN) {
21925                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21926         }
21927         if (flags & NDR_OUT) {
21928                 if (r->out.data == NULL) {
21929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21930                 }
21931                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
21932                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21933         }
21934         return NDR_ERR_SUCCESS;
21935 }
21936
21937 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21938 {
21939         TALLOC_CTX *_mem_save_handle_0;
21940         if (flags & NDR_IN) {
21941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21942                         NDR_PULL_ALLOC(ndr, r->in.handle);
21943                 }
21944                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21945                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21946                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21948                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21949                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21950                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21951                         return 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));
21952                 }
21953                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21954                 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));
21955                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
21956                 {
21957                         struct ndr_pull *_ndr_data;
21958                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21959                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21960                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21961                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21962                 }
21963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21964         }
21965         if (flags & NDR_OUT) {
21966                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21967         }
21968         return NDR_ERR_SUCCESS;
21969 }
21970
21971 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21972 {
21973         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21974         ndr->depth++;
21975         if (flags & NDR_SET_VALUES) {
21976                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21977         }
21978         if (flags & NDR_IN) {
21979                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21980                 ndr->depth++;
21981                 ndr_print_ptr(ndr, "handle", r->in.handle);
21982                 ndr->depth++;
21983                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21984                 ndr->depth--;
21985                 ndr_print_string(ndr, "value_name", r->in.value_name);
21986                 ndr_print_winreg_Type(ndr, "type", r->in.type);
21987                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21988                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21989                 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);
21990                 ndr->depth--;
21991         }
21992         if (flags & NDR_OUT) {
21993                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21994                 ndr->depth++;
21995                 ndr_print_WERROR(ndr, "result", r->out.result);
21996                 ndr->depth--;
21997         }
21998         ndr->depth--;
21999 }
22000
22001 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
22002 {
22003         if (flags & NDR_IN) {
22004         }
22005         if (flags & NDR_OUT) {
22006                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22007         }
22008         return NDR_ERR_SUCCESS;
22009 }
22010
22011 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
22012 {
22013         if (flags & NDR_IN) {
22014         }
22015         if (flags & NDR_OUT) {
22016                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22017         }
22018         return NDR_ERR_SUCCESS;
22019 }
22020
22021 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
22022 {
22023         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
22024         ndr->depth++;
22025         if (flags & NDR_SET_VALUES) {
22026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22027         }
22028         if (flags & NDR_IN) {
22029                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
22030                 ndr->depth++;
22031                 ndr->depth--;
22032         }
22033         if (flags & NDR_OUT) {
22034                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
22035                 ndr->depth++;
22036                 ndr_print_WERROR(ndr, "result", r->out.result);
22037                 ndr->depth--;
22038         }
22039         ndr->depth--;
22040 }
22041
22042 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
22043 {
22044         if (flags & NDR_IN) {
22045                 if (r->in.handle == NULL) {
22046                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22047                 }
22048                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22049         }
22050         if (flags & NDR_OUT) {
22051                 if (r->out.handle == NULL) {
22052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22053                 }
22054                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22055                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22056         }
22057         return NDR_ERR_SUCCESS;
22058 }
22059
22060 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
22061 {
22062         TALLOC_CTX *_mem_save_handle_0;
22063         if (flags & NDR_IN) {
22064                 ZERO_STRUCT(r->out);
22065
22066                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22067                         NDR_PULL_ALLOC(ndr, r->in.handle);
22068                 }
22069                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22070                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22071                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22072                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22073                 NDR_PULL_ALLOC(ndr, r->out.handle);
22074                 *r->out.handle = *r->in.handle;
22075         }
22076         if (flags & NDR_OUT) {
22077                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22078                         NDR_PULL_ALLOC(ndr, r->out.handle);
22079                 }
22080                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22081                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22082                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22083                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22084                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22085         }
22086         return NDR_ERR_SUCCESS;
22087 }
22088
22089 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
22090 {
22091         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
22092         ndr->depth++;
22093         if (flags & NDR_SET_VALUES) {
22094                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22095         }
22096         if (flags & NDR_IN) {
22097                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
22098                 ndr->depth++;
22099                 ndr_print_ptr(ndr, "handle", r->in.handle);
22100                 ndr->depth++;
22101                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22102                 ndr->depth--;
22103                 ndr->depth--;
22104         }
22105         if (flags & NDR_OUT) {
22106                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
22107                 ndr->depth++;
22108                 ndr_print_ptr(ndr, "handle", r->out.handle);
22109                 ndr->depth++;
22110                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22111                 ndr->depth--;
22112                 ndr_print_WERROR(ndr, "result", r->out.result);
22113                 ndr->depth--;
22114         }
22115         ndr->depth--;
22116 }
22117
22118 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
22119 {
22120         if (flags & NDR_IN) {
22121                 if (r->in.handle == NULL) {
22122                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22123                 }
22124                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22126                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22127                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22128         }
22129         if (flags & NDR_OUT) {
22130                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22131         }
22132         return NDR_ERR_SUCCESS;
22133 }
22134
22135 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
22136 {
22137         TALLOC_CTX *_mem_save_handle_0;
22138         if (flags & NDR_IN) {
22139                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22140                         NDR_PULL_ALLOC(ndr, r->in.handle);
22141                 }
22142                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22143                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22144                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22147                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22148                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22149         }
22150         if (flags & NDR_OUT) {
22151                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22152         }
22153         return NDR_ERR_SUCCESS;
22154 }
22155
22156 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
22157 {
22158         ndr_print_struct(ndr, name, "spoolss_AddForm");
22159         ndr->depth++;
22160         if (flags & NDR_SET_VALUES) {
22161                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22162         }
22163         if (flags & NDR_IN) {
22164                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
22165                 ndr->depth++;
22166                 ndr_print_ptr(ndr, "handle", r->in.handle);
22167                 ndr->depth++;
22168                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22169                 ndr->depth--;
22170                 ndr_print_uint32(ndr, "level", r->in.level);
22171                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22172                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22173                 ndr->depth--;
22174         }
22175         if (flags & NDR_OUT) {
22176                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22177                 ndr->depth++;
22178                 ndr_print_WERROR(ndr, "result", r->out.result);
22179                 ndr->depth--;
22180         }
22181         ndr->depth--;
22182 }
22183
22184 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22185 {
22186         if (flags & NDR_IN) {
22187                 if (r->in.handle == NULL) {
22188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22189                 }
22190                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22194                 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));
22195         }
22196         if (flags & NDR_OUT) {
22197                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22198         }
22199         return NDR_ERR_SUCCESS;
22200 }
22201
22202 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22203 {
22204         TALLOC_CTX *_mem_save_handle_0;
22205         if (flags & NDR_IN) {
22206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22207                         NDR_PULL_ALLOC(ndr, r->in.handle);
22208                 }
22209                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22210                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22211                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22212                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22213                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22214                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22215                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22216                         return 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));
22217                 }
22218                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22219                 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));
22220         }
22221         if (flags & NDR_OUT) {
22222                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22223         }
22224         return NDR_ERR_SUCCESS;
22225 }
22226
22227 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22228 {
22229         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22230         ndr->depth++;
22231         if (flags & NDR_SET_VALUES) {
22232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22233         }
22234         if (flags & NDR_IN) {
22235                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22236                 ndr->depth++;
22237                 ndr_print_ptr(ndr, "handle", r->in.handle);
22238                 ndr->depth++;
22239                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22240                 ndr->depth--;
22241                 ndr_print_string(ndr, "form_name", r->in.form_name);
22242                 ndr->depth--;
22243         }
22244         if (flags & NDR_OUT) {
22245                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22246                 ndr->depth++;
22247                 ndr_print_WERROR(ndr, "result", r->out.result);
22248                 ndr->depth--;
22249         }
22250         ndr->depth--;
22251 }
22252
22253 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22254 {
22255         if (flags & NDR_IN) {
22256                 if (r->in.handle == NULL) {
22257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22258                 }
22259                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22263                 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));
22264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22266                 if (r->in.buffer) {
22267                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22268                 }
22269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22270         }
22271         if (flags & NDR_OUT) {
22272                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22273                 if (r->out.info) {
22274                         {
22275                                 struct ndr_push *_ndr_info;
22276                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22277                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22278                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22279                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22280                         }
22281                 }
22282                 if (r->out.needed == NULL) {
22283                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22284                 }
22285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22286                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22287         }
22288         return NDR_ERR_SUCCESS;
22289 }
22290
22291 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22292 {
22293         uint32_t _ptr_buffer;
22294         uint32_t _ptr_info;
22295         TALLOC_CTX *_mem_save_handle_0;
22296         TALLOC_CTX *_mem_save_buffer_0;
22297         TALLOC_CTX *_mem_save_info_0;
22298         TALLOC_CTX *_mem_save_needed_0;
22299         if (flags & NDR_IN) {
22300                 ZERO_STRUCT(r->out);
22301
22302                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22303                         NDR_PULL_ALLOC(ndr, r->in.handle);
22304                 }
22305                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22306                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22307                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22308                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22309                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22310                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22311                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22312                         return 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));
22313                 }
22314                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22315                 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));
22316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22318                 if (_ptr_buffer) {
22319                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22320                 } else {
22321                         r->in.buffer = NULL;
22322                 }
22323                 if (r->in.buffer) {
22324                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22325                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22326                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22328                 }
22329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22330                 NDR_PULL_ALLOC(ndr, r->out.needed);
22331                 ZERO_STRUCTP(r->out.needed);
22332         }
22333         if (flags & NDR_OUT) {
22334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22335                 if (_ptr_info) {
22336                         NDR_PULL_ALLOC(ndr, r->out.info);
22337                 } else {
22338                         r->out.info = NULL;
22339                 }
22340                 if (r->out.info) {
22341                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22342                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22343                         {
22344                                 struct ndr_pull *_ndr_info;
22345                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22346                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22347                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22348                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22349                         }
22350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22351                 }
22352                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22353                         NDR_PULL_ALLOC(ndr, r->out.needed);
22354                 }
22355                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22356                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22358                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22359                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22360         }
22361         return NDR_ERR_SUCCESS;
22362 }
22363
22364 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22365 {
22366         ndr_print_struct(ndr, name, "spoolss_GetForm");
22367         ndr->depth++;
22368         if (flags & NDR_SET_VALUES) {
22369                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22370         }
22371         if (flags & NDR_IN) {
22372                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22373                 ndr->depth++;
22374                 ndr_print_ptr(ndr, "handle", r->in.handle);
22375                 ndr->depth++;
22376                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22377                 ndr->depth--;
22378                 ndr_print_string(ndr, "form_name", r->in.form_name);
22379                 ndr_print_uint32(ndr, "level", r->in.level);
22380                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22381                 ndr->depth++;
22382                 if (r->in.buffer) {
22383                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22384                 }
22385                 ndr->depth--;
22386                 ndr_print_uint32(ndr, "offered", r->in.offered);
22387                 ndr->depth--;
22388         }
22389         if (flags & NDR_OUT) {
22390                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22391                 ndr->depth++;
22392                 ndr_print_ptr(ndr, "info", r->out.info);
22393                 ndr->depth++;
22394                 if (r->out.info) {
22395                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22396                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22397                 }
22398                 ndr->depth--;
22399                 ndr_print_ptr(ndr, "needed", r->out.needed);
22400                 ndr->depth++;
22401                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22402                 ndr->depth--;
22403                 ndr_print_WERROR(ndr, "result", r->out.result);
22404                 ndr->depth--;
22405         }
22406         ndr->depth--;
22407 }
22408
22409 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22410 {
22411         if (flags & NDR_IN) {
22412                 if (r->in.handle == NULL) {
22413                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22414                 }
22415                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22419                 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));
22420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22421                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22422                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22423         }
22424         if (flags & NDR_OUT) {
22425                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22426         }
22427         return NDR_ERR_SUCCESS;
22428 }
22429
22430 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22431 {
22432         TALLOC_CTX *_mem_save_handle_0;
22433         if (flags & NDR_IN) {
22434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22435                         NDR_PULL_ALLOC(ndr, r->in.handle);
22436                 }
22437                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22438                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22439                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22440                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22441                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22442                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22443                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22444                         return 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));
22445                 }
22446                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22447                 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));
22448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22449                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22450                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22451         }
22452         if (flags & NDR_OUT) {
22453                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22454         }
22455         return NDR_ERR_SUCCESS;
22456 }
22457
22458 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22459 {
22460         ndr_print_struct(ndr, name, "spoolss_SetForm");
22461         ndr->depth++;
22462         if (flags & NDR_SET_VALUES) {
22463                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22464         }
22465         if (flags & NDR_IN) {
22466                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22467                 ndr->depth++;
22468                 ndr_print_ptr(ndr, "handle", r->in.handle);
22469                 ndr->depth++;
22470                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22471                 ndr->depth--;
22472                 ndr_print_string(ndr, "form_name", r->in.form_name);
22473                 ndr_print_uint32(ndr, "level", r->in.level);
22474                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22475                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22476                 ndr->depth--;
22477         }
22478         if (flags & NDR_OUT) {
22479                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22480                 ndr->depth++;
22481                 ndr_print_WERROR(ndr, "result", r->out.result);
22482                 ndr->depth--;
22483         }
22484         ndr->depth--;
22485 }
22486
22487 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22488 {
22489         if (flags & NDR_IN) {
22490                 if (r->in.handle == NULL) {
22491                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22492                 }
22493                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22496                 if (r->in.buffer) {
22497                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22498                 }
22499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22500         }
22501         if (flags & NDR_OUT) {
22502                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22503                 if (r->out.info) {
22504                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22505                 }
22506                 if (r->out.needed == NULL) {
22507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22508                 }
22509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22510                 if (r->out.count == NULL) {
22511                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22512                 }
22513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22514                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22515         }
22516         return NDR_ERR_SUCCESS;
22517 }
22518
22519 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22520 {
22521         uint32_t _ptr_buffer;
22522         uint32_t _ptr_info;
22523         TALLOC_CTX *_mem_save_handle_0;
22524         TALLOC_CTX *_mem_save_buffer_0;
22525         TALLOC_CTX *_mem_save_info_0;
22526         TALLOC_CTX *_mem_save_needed_0;
22527         TALLOC_CTX *_mem_save_count_0;
22528         if (flags & NDR_IN) {
22529                 ZERO_STRUCT(r->out);
22530
22531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22532                         NDR_PULL_ALLOC(ndr, r->in.handle);
22533                 }
22534                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22535                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22536                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22540                 if (_ptr_buffer) {
22541                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22542                 } else {
22543                         r->in.buffer = NULL;
22544                 }
22545                 if (r->in.buffer) {
22546                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22547                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22548                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22550                 }
22551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22552                 NDR_PULL_ALLOC(ndr, r->out.needed);
22553                 ZERO_STRUCTP(r->out.needed);
22554                 NDR_PULL_ALLOC(ndr, r->out.count);
22555                 ZERO_STRUCTP(r->out.count);
22556         }
22557         if (flags & NDR_OUT) {
22558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22559                 if (_ptr_info) {
22560                         NDR_PULL_ALLOC(ndr, r->out.info);
22561                 } else {
22562                         r->out.info = NULL;
22563                 }
22564                 if (r->out.info) {
22565                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22566                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22567                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22569                 }
22570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22571                         NDR_PULL_ALLOC(ndr, r->out.needed);
22572                 }
22573                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22574                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22577                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22578                         NDR_PULL_ALLOC(ndr, r->out.count);
22579                 }
22580                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22581                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22585         }
22586         return NDR_ERR_SUCCESS;
22587 }
22588
22589 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22590 {
22591         uint32_t cntr_info_0;
22592         if (flags & NDR_IN) {
22593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22595         }
22596         if (flags & NDR_OUT) {
22597                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22598                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22599                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22600                 }
22601                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22602                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22603                 }
22604         }
22605         return NDR_ERR_SUCCESS;
22606 }
22607
22608 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22609 {
22610         uint32_t cntr_info_0;
22611         TALLOC_CTX *_mem_save_info_0;
22612         if (flags & NDR_IN) {
22613                 ZERO_STRUCT(r->out);
22614
22615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22617         }
22618         if (flags & NDR_OUT) {
22619                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22620                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22621                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22622                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22623                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22624                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22625                 }
22626                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22627                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22628                 }
22629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22630         }
22631         return NDR_ERR_SUCCESS;
22632 }
22633
22634 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22635 {
22636         uint32_t cntr_info_2;
22637         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22638         ndr->depth++;
22639         if (flags & NDR_SET_VALUES) {
22640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22641         }
22642         if (flags & NDR_IN) {
22643                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22644                 ndr->depth++;
22645                 ndr_print_ptr(ndr, "handle", r->in.handle);
22646                 ndr->depth++;
22647                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22648                 ndr->depth--;
22649                 ndr_print_uint32(ndr, "level", r->in.level);
22650                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22651                 ndr->depth++;
22652                 if (r->in.buffer) {
22653                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22654                 }
22655                 ndr->depth--;
22656                 ndr_print_uint32(ndr, "offered", r->in.offered);
22657                 ndr->depth--;
22658         }
22659         if (flags & NDR_OUT) {
22660                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22661                 ndr->depth++;
22662                 ndr_print_ptr(ndr, "count", r->out.count);
22663                 ndr->depth++;
22664                 ndr_print_uint32(ndr, "count", *r->out.count);
22665                 ndr->depth--;
22666                 ndr_print_ptr(ndr, "info", r->out.info);
22667                 ndr->depth++;
22668                 ndr_print_ptr(ndr, "info", *r->out.info);
22669                 ndr->depth++;
22670                 if (*r->out.info) {
22671                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22672                         ndr->depth++;
22673                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22674                                 char *idx_2=NULL;
22675                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22676                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22677                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22678                                         free(idx_2);
22679                                 }
22680                         }
22681                         ndr->depth--;
22682                 }
22683                 ndr->depth--;
22684                 ndr->depth--;
22685                 ndr_print_ptr(ndr, "needed", r->out.needed);
22686                 ndr->depth++;
22687                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22688                 ndr->depth--;
22689                 ndr_print_WERROR(ndr, "result", r->out.result);
22690                 ndr->depth--;
22691         }
22692         ndr->depth--;
22693 }
22694
22695 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22696 {
22697         if (flags & NDR_IN) {
22698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22699                 if (r->in.servername) {
22700                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22703                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22704                 }
22705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22707                 if (r->in.buffer) {
22708                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22709                 }
22710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22711         }
22712         if (flags & NDR_OUT) {
22713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22714                 if (r->out.info) {
22715                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22716                 }
22717                 if (r->out.needed == NULL) {
22718                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22719                 }
22720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22721                 if (r->out.count == NULL) {
22722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22723                 }
22724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22725                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22726         }
22727         return NDR_ERR_SUCCESS;
22728 }
22729
22730 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22731 {
22732         uint32_t _ptr_servername;
22733         uint32_t _ptr_buffer;
22734         uint32_t _ptr_info;
22735         TALLOC_CTX *_mem_save_servername_0;
22736         TALLOC_CTX *_mem_save_buffer_0;
22737         TALLOC_CTX *_mem_save_info_0;
22738         TALLOC_CTX *_mem_save_needed_0;
22739         TALLOC_CTX *_mem_save_count_0;
22740         if (flags & NDR_IN) {
22741                 ZERO_STRUCT(r->out);
22742
22743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22744                 if (_ptr_servername) {
22745                         NDR_PULL_ALLOC(ndr, r->in.servername);
22746                 } else {
22747                         r->in.servername = NULL;
22748                 }
22749                 if (r->in.servername) {
22750                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22751                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22752                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22753                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22754                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22755                                 return 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));
22756                         }
22757                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22758                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22760                 }
22761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22762                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22763                 if (_ptr_buffer) {
22764                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22765                 } else {
22766                         r->in.buffer = NULL;
22767                 }
22768                 if (r->in.buffer) {
22769                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22770                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22771                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22773                 }
22774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22775                 NDR_PULL_ALLOC(ndr, r->out.needed);
22776                 ZERO_STRUCTP(r->out.needed);
22777                 NDR_PULL_ALLOC(ndr, r->out.count);
22778                 ZERO_STRUCTP(r->out.count);
22779         }
22780         if (flags & NDR_OUT) {
22781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22782                 if (_ptr_info) {
22783                         NDR_PULL_ALLOC(ndr, r->out.info);
22784                 } else {
22785                         r->out.info = NULL;
22786                 }
22787                 if (r->out.info) {
22788                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22789                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22790                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22792                 }
22793                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22794                         NDR_PULL_ALLOC(ndr, r->out.needed);
22795                 }
22796                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22797                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22799                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22801                         NDR_PULL_ALLOC(ndr, r->out.count);
22802                 }
22803                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22804                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22807                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22808         }
22809         return NDR_ERR_SUCCESS;
22810 }
22811
22812 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22813 {
22814         uint32_t cntr_info_0;
22815         if (flags & NDR_IN) {
22816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22818         }
22819         if (flags & NDR_OUT) {
22820                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22821                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22822                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22823                 }
22824                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22825                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22826                 }
22827         }
22828         return NDR_ERR_SUCCESS;
22829 }
22830
22831 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22832 {
22833         uint32_t cntr_info_0;
22834         TALLOC_CTX *_mem_save_info_0;
22835         if (flags & NDR_IN) {
22836                 ZERO_STRUCT(r->out);
22837
22838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22840         }
22841         if (flags & NDR_OUT) {
22842                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22843                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22844                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22845                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22846                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22847                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22848                 }
22849                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22850                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22851                 }
22852                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22853         }
22854         return NDR_ERR_SUCCESS;
22855 }
22856
22857 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22858 {
22859         uint32_t cntr_info_2;
22860         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22861         ndr->depth++;
22862         if (flags & NDR_SET_VALUES) {
22863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22864         }
22865         if (flags & NDR_IN) {
22866                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22867                 ndr->depth++;
22868                 ndr_print_ptr(ndr, "servername", r->in.servername);
22869                 ndr->depth++;
22870                 if (r->in.servername) {
22871                         ndr_print_string(ndr, "servername", r->in.servername);
22872                 }
22873                 ndr->depth--;
22874                 ndr_print_uint32(ndr, "level", r->in.level);
22875                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22876                 ndr->depth++;
22877                 if (r->in.buffer) {
22878                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22879                 }
22880                 ndr->depth--;
22881                 ndr_print_uint32(ndr, "offered", r->in.offered);
22882                 ndr->depth--;
22883         }
22884         if (flags & NDR_OUT) {
22885                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22886                 ndr->depth++;
22887                 ndr_print_ptr(ndr, "count", r->out.count);
22888                 ndr->depth++;
22889                 ndr_print_uint32(ndr, "count", *r->out.count);
22890                 ndr->depth--;
22891                 ndr_print_ptr(ndr, "info", r->out.info);
22892                 ndr->depth++;
22893                 ndr_print_ptr(ndr, "info", *r->out.info);
22894                 ndr->depth++;
22895                 if (*r->out.info) {
22896                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22897                         ndr->depth++;
22898                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22899                                 char *idx_2=NULL;
22900                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22901                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22902                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22903                                         free(idx_2);
22904                                 }
22905                         }
22906                         ndr->depth--;
22907                 }
22908                 ndr->depth--;
22909                 ndr->depth--;
22910                 ndr_print_ptr(ndr, "needed", r->out.needed);
22911                 ndr->depth++;
22912                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22913                 ndr->depth--;
22914                 ndr_print_WERROR(ndr, "result", r->out.result);
22915                 ndr->depth--;
22916         }
22917         ndr->depth--;
22918 }
22919
22920 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22921 {
22922         if (flags & NDR_IN) {
22923                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22924                 if (r->in.servername) {
22925                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22926                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22928                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22929                 }
22930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22931                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22932                 if (r->in.buffer) {
22933                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22934                 }
22935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22936         }
22937         if (flags & NDR_OUT) {
22938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22939                 if (r->out.info) {
22940                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22941                 }
22942                 if (r->out.needed == NULL) {
22943                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22944                 }
22945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22946                 if (r->out.count == NULL) {
22947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22948                 }
22949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22950                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22951         }
22952         return NDR_ERR_SUCCESS;
22953 }
22954
22955 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22956 {
22957         uint32_t _ptr_servername;
22958         uint32_t _ptr_buffer;
22959         uint32_t _ptr_info;
22960         TALLOC_CTX *_mem_save_servername_0;
22961         TALLOC_CTX *_mem_save_buffer_0;
22962         TALLOC_CTX *_mem_save_info_0;
22963         TALLOC_CTX *_mem_save_needed_0;
22964         TALLOC_CTX *_mem_save_count_0;
22965         if (flags & NDR_IN) {
22966                 ZERO_STRUCT(r->out);
22967
22968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22969                 if (_ptr_servername) {
22970                         NDR_PULL_ALLOC(ndr, r->in.servername);
22971                 } else {
22972                         r->in.servername = NULL;
22973                 }
22974                 if (r->in.servername) {
22975                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22976                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22977                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22978                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22979                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22980                                 return 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));
22981                         }
22982                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22983                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22985                 }
22986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22988                 if (_ptr_buffer) {
22989                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22990                 } else {
22991                         r->in.buffer = NULL;
22992                 }
22993                 if (r->in.buffer) {
22994                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22995                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22996                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22998                 }
22999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23000                 NDR_PULL_ALLOC(ndr, r->out.needed);
23001                 ZERO_STRUCTP(r->out.needed);
23002                 NDR_PULL_ALLOC(ndr, r->out.count);
23003                 ZERO_STRUCTP(r->out.count);
23004         }
23005         if (flags & NDR_OUT) {
23006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23007                 if (_ptr_info) {
23008                         NDR_PULL_ALLOC(ndr, r->out.info);
23009                 } else {
23010                         r->out.info = NULL;
23011                 }
23012                 if (r->out.info) {
23013                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23014                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23015                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23017                 }
23018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23019                         NDR_PULL_ALLOC(ndr, r->out.needed);
23020                 }
23021                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23022                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23026                         NDR_PULL_ALLOC(ndr, r->out.count);
23027                 }
23028                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23029                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23033         }
23034         return NDR_ERR_SUCCESS;
23035 }
23036
23037 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
23038 {
23039         uint32_t cntr_info_0;
23040         if (flags & NDR_IN) {
23041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23043         }
23044         if (flags & NDR_OUT) {
23045                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23046                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23047                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23048                 }
23049                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23050                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23051                 }
23052         }
23053         return NDR_ERR_SUCCESS;
23054 }
23055
23056 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
23057 {
23058         uint32_t cntr_info_0;
23059         TALLOC_CTX *_mem_save_info_0;
23060         if (flags & NDR_IN) {
23061                 ZERO_STRUCT(r->out);
23062
23063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23065         }
23066         if (flags & NDR_OUT) {
23067                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23068                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23069                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23070                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23071                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23072                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23073                 }
23074                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23075                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23076                 }
23077                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23078         }
23079         return NDR_ERR_SUCCESS;
23080 }
23081
23082 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
23083 {
23084         uint32_t cntr_info_2;
23085         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
23086         ndr->depth++;
23087         if (flags & NDR_SET_VALUES) {
23088                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23089         }
23090         if (flags & NDR_IN) {
23091                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
23092                 ndr->depth++;
23093                 ndr_print_ptr(ndr, "servername", r->in.servername);
23094                 ndr->depth++;
23095                 if (r->in.servername) {
23096                         ndr_print_string(ndr, "servername", r->in.servername);
23097                 }
23098                 ndr->depth--;
23099                 ndr_print_uint32(ndr, "level", r->in.level);
23100                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23101                 ndr->depth++;
23102                 if (r->in.buffer) {
23103                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23104                 }
23105                 ndr->depth--;
23106                 ndr_print_uint32(ndr, "offered", r->in.offered);
23107                 ndr->depth--;
23108         }
23109         if (flags & NDR_OUT) {
23110                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
23111                 ndr->depth++;
23112                 ndr_print_ptr(ndr, "count", r->out.count);
23113                 ndr->depth++;
23114                 ndr_print_uint32(ndr, "count", *r->out.count);
23115                 ndr->depth--;
23116                 ndr_print_ptr(ndr, "info", r->out.info);
23117                 ndr->depth++;
23118                 ndr_print_ptr(ndr, "info", *r->out.info);
23119                 ndr->depth++;
23120                 if (*r->out.info) {
23121                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23122                         ndr->depth++;
23123                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23124                                 char *idx_2=NULL;
23125                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23126                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23127                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23128                                         free(idx_2);
23129                                 }
23130                         }
23131                         ndr->depth--;
23132                 }
23133                 ndr->depth--;
23134                 ndr->depth--;
23135                 ndr_print_ptr(ndr, "needed", r->out.needed);
23136                 ndr->depth++;
23137                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23138                 ndr->depth--;
23139                 ndr_print_WERROR(ndr, "result", r->out.result);
23140                 ndr->depth--;
23141         }
23142         ndr->depth--;
23143 }
23144
23145 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
23146 {
23147         if (flags & NDR_IN) {
23148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
23149                 if (r->in.server_name) {
23150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23153                         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));
23154                 }
23155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
23156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23159                 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));
23160         }
23161         if (flags & NDR_OUT) {
23162                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23163         }
23164         return NDR_ERR_SUCCESS;
23165 }
23166
23167 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23168 {
23169         uint32_t _ptr_server_name;
23170         TALLOC_CTX *_mem_save_server_name_0;
23171         if (flags & NDR_IN) {
23172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23173                 if (_ptr_server_name) {
23174                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23175                 } else {
23176                         r->in.server_name = NULL;
23177                 }
23178                 if (r->in.server_name) {
23179                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23180                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23183                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23184                                 return 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));
23185                         }
23186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23187                         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));
23188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23189                 }
23190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23191                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23192                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23193                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23194                         return 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));
23195                 }
23196                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23197                 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));
23198         }
23199         if (flags & NDR_OUT) {
23200                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23201         }
23202         return NDR_ERR_SUCCESS;
23203 }
23204
23205 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23206 {
23207         ndr_print_struct(ndr, name, "spoolss_AddPort");
23208         ndr->depth++;
23209         if (flags & NDR_SET_VALUES) {
23210                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23211         }
23212         if (flags & NDR_IN) {
23213                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23214                 ndr->depth++;
23215                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23216                 ndr->depth++;
23217                 if (r->in.server_name) {
23218                         ndr_print_string(ndr, "server_name", r->in.server_name);
23219                 }
23220                 ndr->depth--;
23221                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23222                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23223                 ndr->depth--;
23224         }
23225         if (flags & NDR_OUT) {
23226                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23227                 ndr->depth++;
23228                 ndr_print_WERROR(ndr, "result", r->out.result);
23229                 ndr->depth--;
23230         }
23231         ndr->depth--;
23232 }
23233
23234 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23235 {
23236         if (flags & NDR_IN) {
23237         }
23238         if (flags & NDR_OUT) {
23239                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23240         }
23241         return NDR_ERR_SUCCESS;
23242 }
23243
23244 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23245 {
23246         if (flags & NDR_IN) {
23247         }
23248         if (flags & NDR_OUT) {
23249                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23250         }
23251         return NDR_ERR_SUCCESS;
23252 }
23253
23254 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23255 {
23256         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23257         ndr->depth++;
23258         if (flags & NDR_SET_VALUES) {
23259                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23260         }
23261         if (flags & NDR_IN) {
23262                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23263                 ndr->depth++;
23264                 ndr->depth--;
23265         }
23266         if (flags & NDR_OUT) {
23267                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23268                 ndr->depth++;
23269                 ndr_print_WERROR(ndr, "result", r->out.result);
23270                 ndr->depth--;
23271         }
23272         ndr->depth--;
23273 }
23274
23275 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23276 {
23277         if (flags & NDR_IN) {
23278         }
23279         if (flags & NDR_OUT) {
23280                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23281         }
23282         return NDR_ERR_SUCCESS;
23283 }
23284
23285 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23286 {
23287         if (flags & NDR_IN) {
23288         }
23289         if (flags & NDR_OUT) {
23290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23291         }
23292         return NDR_ERR_SUCCESS;
23293 }
23294
23295 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23296 {
23297         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23298         ndr->depth++;
23299         if (flags & NDR_SET_VALUES) {
23300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23301         }
23302         if (flags & NDR_IN) {
23303                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23304                 ndr->depth++;
23305                 ndr->depth--;
23306         }
23307         if (flags & NDR_OUT) {
23308                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23309                 ndr->depth++;
23310                 ndr_print_WERROR(ndr, "result", r->out.result);
23311                 ndr->depth--;
23312         }
23313         ndr->depth--;
23314 }
23315
23316 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23317 {
23318         if (flags & NDR_IN) {
23319         }
23320         if (flags & NDR_OUT) {
23321                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23322         }
23323         return NDR_ERR_SUCCESS;
23324 }
23325
23326 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23327 {
23328         if (flags & NDR_IN) {
23329         }
23330         if (flags & NDR_OUT) {
23331                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23332         }
23333         return NDR_ERR_SUCCESS;
23334 }
23335
23336 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23337 {
23338         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23339         ndr->depth++;
23340         if (flags & NDR_SET_VALUES) {
23341                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23342         }
23343         if (flags & NDR_IN) {
23344                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23345                 ndr->depth++;
23346                 ndr->depth--;
23347         }
23348         if (flags & NDR_OUT) {
23349                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23350                 ndr->depth++;
23351                 ndr_print_WERROR(ndr, "result", r->out.result);
23352                 ndr->depth--;
23353         }
23354         ndr->depth--;
23355 }
23356
23357 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23358 {
23359         if (flags & NDR_IN) {
23360         }
23361         if (flags & NDR_OUT) {
23362                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23363         }
23364         return NDR_ERR_SUCCESS;
23365 }
23366
23367 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23368 {
23369         if (flags & NDR_IN) {
23370         }
23371         if (flags & NDR_OUT) {
23372                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23373         }
23374         return NDR_ERR_SUCCESS;
23375 }
23376
23377 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23378 {
23379         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23380         ndr->depth++;
23381         if (flags & NDR_SET_VALUES) {
23382                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23383         }
23384         if (flags & NDR_IN) {
23385                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23386                 ndr->depth++;
23387                 ndr->depth--;
23388         }
23389         if (flags & NDR_OUT) {
23390                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23391                 ndr->depth++;
23392                 ndr_print_WERROR(ndr, "result", r->out.result);
23393                 ndr->depth--;
23394         }
23395         ndr->depth--;
23396 }
23397
23398 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23399 {
23400         if (flags & NDR_IN) {
23401         }
23402         if (flags & NDR_OUT) {
23403                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23404         }
23405         return NDR_ERR_SUCCESS;
23406 }
23407
23408 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23409 {
23410         if (flags & NDR_IN) {
23411         }
23412         if (flags & NDR_OUT) {
23413                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23414         }
23415         return NDR_ERR_SUCCESS;
23416 }
23417
23418 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23419 {
23420         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23421         ndr->depth++;
23422         if (flags & NDR_SET_VALUES) {
23423                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23424         }
23425         if (flags & NDR_IN) {
23426                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23427                 ndr->depth++;
23428                 ndr->depth--;
23429         }
23430         if (flags & NDR_OUT) {
23431                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23432                 ndr->depth++;
23433                 ndr_print_WERROR(ndr, "result", r->out.result);
23434                 ndr->depth--;
23435         }
23436         ndr->depth--;
23437 }
23438
23439 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23440 {
23441         if (flags & NDR_IN) {
23442         }
23443         if (flags & NDR_OUT) {
23444                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23445         }
23446         return NDR_ERR_SUCCESS;
23447 }
23448
23449 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23450 {
23451         if (flags & NDR_IN) {
23452         }
23453         if (flags & NDR_OUT) {
23454                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23455         }
23456         return NDR_ERR_SUCCESS;
23457 }
23458
23459 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23460 {
23461         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23462         ndr->depth++;
23463         if (flags & NDR_SET_VALUES) {
23464                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23465         }
23466         if (flags & NDR_IN) {
23467                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23468                 ndr->depth++;
23469                 ndr->depth--;
23470         }
23471         if (flags & NDR_OUT) {
23472                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23473                 ndr->depth++;
23474                 ndr_print_WERROR(ndr, "result", r->out.result);
23475                 ndr->depth--;
23476         }
23477         ndr->depth--;
23478 }
23479
23480 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23481 {
23482         if (flags & NDR_IN) {
23483         }
23484         if (flags & NDR_OUT) {
23485                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23486         }
23487         return NDR_ERR_SUCCESS;
23488 }
23489
23490 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23491 {
23492         if (flags & NDR_IN) {
23493         }
23494         if (flags & NDR_OUT) {
23495                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23496         }
23497         return NDR_ERR_SUCCESS;
23498 }
23499
23500 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23501 {
23502         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23503         ndr->depth++;
23504         if (flags & NDR_SET_VALUES) {
23505                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23506         }
23507         if (flags & NDR_IN) {
23508                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23509                 ndr->depth++;
23510                 ndr->depth--;
23511         }
23512         if (flags & NDR_OUT) {
23513                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23514                 ndr->depth++;
23515                 ndr_print_WERROR(ndr, "result", r->out.result);
23516                 ndr->depth--;
23517         }
23518         ndr->depth--;
23519 }
23520
23521 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23522 {
23523         if (flags & NDR_IN) {
23524         }
23525         if (flags & NDR_OUT) {
23526                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23527         }
23528         return NDR_ERR_SUCCESS;
23529 }
23530
23531 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23532 {
23533         if (flags & NDR_IN) {
23534         }
23535         if (flags & NDR_OUT) {
23536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23537         }
23538         return NDR_ERR_SUCCESS;
23539 }
23540
23541 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23542 {
23543         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23544         ndr->depth++;
23545         if (flags & NDR_SET_VALUES) {
23546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23547         }
23548         if (flags & NDR_IN) {
23549                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23550                 ndr->depth++;
23551                 ndr->depth--;
23552         }
23553         if (flags & NDR_OUT) {
23554                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23555                 ndr->depth++;
23556                 ndr_print_WERROR(ndr, "result", r->out.result);
23557                 ndr->depth--;
23558         }
23559         ndr->depth--;
23560 }
23561
23562 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23563 {
23564         if (flags & NDR_IN) {
23565         }
23566         if (flags & NDR_OUT) {
23567                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23568         }
23569         return NDR_ERR_SUCCESS;
23570 }
23571
23572 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23573 {
23574         if (flags & NDR_IN) {
23575         }
23576         if (flags & NDR_OUT) {
23577                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23578         }
23579         return NDR_ERR_SUCCESS;
23580 }
23581
23582 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23583 {
23584         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23585         ndr->depth++;
23586         if (flags & NDR_SET_VALUES) {
23587                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23588         }
23589         if (flags & NDR_IN) {
23590                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23591                 ndr->depth++;
23592                 ndr->depth--;
23593         }
23594         if (flags & NDR_OUT) {
23595                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23596                 ndr->depth++;
23597                 ndr_print_WERROR(ndr, "result", r->out.result);
23598                 ndr->depth--;
23599         }
23600         ndr->depth--;
23601 }
23602
23603 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23604 {
23605         if (flags & NDR_IN) {
23606         }
23607         if (flags & NDR_OUT) {
23608                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23609         }
23610         return NDR_ERR_SUCCESS;
23611 }
23612
23613 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23614 {
23615         if (flags & NDR_IN) {
23616         }
23617         if (flags & NDR_OUT) {
23618                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23619         }
23620         return NDR_ERR_SUCCESS;
23621 }
23622
23623 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23624 {
23625         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23626         ndr->depth++;
23627         if (flags & NDR_SET_VALUES) {
23628                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23629         }
23630         if (flags & NDR_IN) {
23631                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23632                 ndr->depth++;
23633                 ndr->depth--;
23634         }
23635         if (flags & NDR_OUT) {
23636                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23637                 ndr->depth++;
23638                 ndr_print_WERROR(ndr, "result", r->out.result);
23639                 ndr->depth--;
23640         }
23641         ndr->depth--;
23642 }
23643
23644 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23645 {
23646         if (flags & NDR_IN) {
23647         }
23648         if (flags & NDR_OUT) {
23649                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23650         }
23651         return NDR_ERR_SUCCESS;
23652 }
23653
23654 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23655 {
23656         if (flags & NDR_IN) {
23657         }
23658         if (flags & NDR_OUT) {
23659                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23660         }
23661         return NDR_ERR_SUCCESS;
23662 }
23663
23664 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23665 {
23666         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23667         ndr->depth++;
23668         if (flags & NDR_SET_VALUES) {
23669                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23670         }
23671         if (flags & NDR_IN) {
23672                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23673                 ndr->depth++;
23674                 ndr->depth--;
23675         }
23676         if (flags & NDR_OUT) {
23677                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23678                 ndr->depth++;
23679                 ndr_print_WERROR(ndr, "result", r->out.result);
23680                 ndr->depth--;
23681         }
23682         ndr->depth--;
23683 }
23684
23685 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23686 {
23687         if (flags & NDR_IN) {
23688         }
23689         if (flags & NDR_OUT) {
23690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23691         }
23692         return NDR_ERR_SUCCESS;
23693 }
23694
23695 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23696 {
23697         if (flags & NDR_IN) {
23698         }
23699         if (flags & NDR_OUT) {
23700                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23701         }
23702         return NDR_ERR_SUCCESS;
23703 }
23704
23705 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23706 {
23707         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23708         ndr->depth++;
23709         if (flags & NDR_SET_VALUES) {
23710                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23711         }
23712         if (flags & NDR_IN) {
23713                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23714                 ndr->depth++;
23715                 ndr->depth--;
23716         }
23717         if (flags & NDR_OUT) {
23718                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23719                 ndr->depth++;
23720                 ndr_print_WERROR(ndr, "result", r->out.result);
23721                 ndr->depth--;
23722         }
23723         ndr->depth--;
23724 }
23725
23726 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23727 {
23728         if (flags & NDR_IN) {
23729         }
23730         if (flags & NDR_OUT) {
23731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23732         }
23733         return NDR_ERR_SUCCESS;
23734 }
23735
23736 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23737 {
23738         if (flags & NDR_IN) {
23739         }
23740         if (flags & NDR_OUT) {
23741                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23742         }
23743         return NDR_ERR_SUCCESS;
23744 }
23745
23746 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23747 {
23748         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23749         ndr->depth++;
23750         if (flags & NDR_SET_VALUES) {
23751                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23752         }
23753         if (flags & NDR_IN) {
23754                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23755                 ndr->depth++;
23756                 ndr->depth--;
23757         }
23758         if (flags & NDR_OUT) {
23759                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23760                 ndr->depth++;
23761                 ndr_print_WERROR(ndr, "result", r->out.result);
23762                 ndr->depth--;
23763         }
23764         ndr->depth--;
23765 }
23766
23767 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23768 {
23769         if (flags & NDR_IN) {
23770                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23771                 if (r->in.servername) {
23772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23773                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23775                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23776                 }
23777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23778                 if (r->in.print_processor_name) {
23779                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23780                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23782                         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));
23783                 }
23784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23786                 if (r->in.buffer) {
23787                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23788                 }
23789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23790         }
23791         if (flags & NDR_OUT) {
23792                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23793                 if (r->out.info) {
23794                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23795                 }
23796                 if (r->out.needed == NULL) {
23797                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23798                 }
23799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23800                 if (r->out.count == NULL) {
23801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23802                 }
23803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23804                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23805         }
23806         return NDR_ERR_SUCCESS;
23807 }
23808
23809 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23810 {
23811         uint32_t _ptr_servername;
23812         uint32_t _ptr_print_processor_name;
23813         uint32_t _ptr_buffer;
23814         uint32_t _ptr_info;
23815         TALLOC_CTX *_mem_save_servername_0;
23816         TALLOC_CTX *_mem_save_print_processor_name_0;
23817         TALLOC_CTX *_mem_save_buffer_0;
23818         TALLOC_CTX *_mem_save_info_0;
23819         TALLOC_CTX *_mem_save_needed_0;
23820         TALLOC_CTX *_mem_save_count_0;
23821         if (flags & NDR_IN) {
23822                 ZERO_STRUCT(r->out);
23823
23824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23825                 if (_ptr_servername) {
23826                         NDR_PULL_ALLOC(ndr, r->in.servername);
23827                 } else {
23828                         r->in.servername = NULL;
23829                 }
23830                 if (r->in.servername) {
23831                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23832                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23833                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23834                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23835                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23836                                 return 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));
23837                         }
23838                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23839                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23841                 }
23842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23843                 if (_ptr_print_processor_name) {
23844                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23845                 } else {
23846                         r->in.print_processor_name = NULL;
23847                 }
23848                 if (r->in.print_processor_name) {
23849                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23850                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23853                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23854                                 return 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));
23855                         }
23856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23857                         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));
23858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23859                 }
23860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23862                 if (_ptr_buffer) {
23863                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23864                 } else {
23865                         r->in.buffer = NULL;
23866                 }
23867                 if (r->in.buffer) {
23868                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23869                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23870                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23872                 }
23873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23874                 NDR_PULL_ALLOC(ndr, r->out.needed);
23875                 ZERO_STRUCTP(r->out.needed);
23876                 NDR_PULL_ALLOC(ndr, r->out.count);
23877                 ZERO_STRUCTP(r->out.count);
23878         }
23879         if (flags & NDR_OUT) {
23880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23881                 if (_ptr_info) {
23882                         NDR_PULL_ALLOC(ndr, r->out.info);
23883                 } else {
23884                         r->out.info = NULL;
23885                 }
23886                 if (r->out.info) {
23887                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23888                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23889                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23891                 }
23892                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23893                         NDR_PULL_ALLOC(ndr, r->out.needed);
23894                 }
23895                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23896                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23899                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23900                         NDR_PULL_ALLOC(ndr, r->out.count);
23901                 }
23902                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23903                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23906                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23907         }
23908         return NDR_ERR_SUCCESS;
23909 }
23910
23911 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
23912 {
23913         uint32_t cntr_info_0;
23914         if (flags & NDR_IN) {
23915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23917         }
23918         if (flags & NDR_OUT) {
23919                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23920                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23921                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23922                 }
23923                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23924                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23925                 }
23926         }
23927         return NDR_ERR_SUCCESS;
23928 }
23929
23930 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
23931 {
23932         uint32_t cntr_info_0;
23933         TALLOC_CTX *_mem_save_info_0;
23934         if (flags & NDR_IN) {
23935                 ZERO_STRUCT(r->out);
23936
23937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23939         }
23940         if (flags & NDR_OUT) {
23941                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23942                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23943                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23944                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23945                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23946                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23947                 }
23948                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23949                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23950                 }
23951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23952         }
23953         return NDR_ERR_SUCCESS;
23954 }
23955
23956 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23957 {
23958         uint32_t cntr_info_2;
23959         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23960         ndr->depth++;
23961         if (flags & NDR_SET_VALUES) {
23962                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23963         }
23964         if (flags & NDR_IN) {
23965                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23966                 ndr->depth++;
23967                 ndr_print_ptr(ndr, "servername", r->in.servername);
23968                 ndr->depth++;
23969                 if (r->in.servername) {
23970                         ndr_print_string(ndr, "servername", r->in.servername);
23971                 }
23972                 ndr->depth--;
23973                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
23974                 ndr->depth++;
23975                 if (r->in.print_processor_name) {
23976                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23977                 }
23978                 ndr->depth--;
23979                 ndr_print_uint32(ndr, "level", r->in.level);
23980                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23981                 ndr->depth++;
23982                 if (r->in.buffer) {
23983                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23984                 }
23985                 ndr->depth--;
23986                 ndr_print_uint32(ndr, "offered", r->in.offered);
23987                 ndr->depth--;
23988         }
23989         if (flags & NDR_OUT) {
23990                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23991                 ndr->depth++;
23992                 ndr_print_ptr(ndr, "count", r->out.count);
23993                 ndr->depth++;
23994                 ndr_print_uint32(ndr, "count", *r->out.count);
23995                 ndr->depth--;
23996                 ndr_print_ptr(ndr, "info", r->out.info);
23997                 ndr->depth++;
23998                 ndr_print_ptr(ndr, "info", *r->out.info);
23999                 ndr->depth++;
24000                 if (*r->out.info) {
24001                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24002                         ndr->depth++;
24003                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24004                                 char *idx_2=NULL;
24005                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24006                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24007                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24008                                         free(idx_2);
24009                                 }
24010                         }
24011                         ndr->depth--;
24012                 }
24013                 ndr->depth--;
24014                 ndr->depth--;
24015                 ndr_print_ptr(ndr, "needed", r->out.needed);
24016                 ndr->depth++;
24017                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24018                 ndr->depth--;
24019                 ndr_print_WERROR(ndr, "result", r->out.result);
24020                 ndr->depth--;
24021         }
24022         ndr->depth--;
24023 }
24024
24025 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
24026 {
24027         if (flags & NDR_IN) {
24028                 if (r->in.handle == NULL) {
24029                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24030                 }
24031                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
24033                 if (r->in.data_type) {
24034                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24037                         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));
24038                 }
24039                 if (r->in.devmode_ctr == NULL) {
24040                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24041                 }
24042                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24043         }
24044         if (flags & NDR_OUT) {
24045                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24046         }
24047         return NDR_ERR_SUCCESS;
24048 }
24049
24050 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
24051 {
24052         uint32_t _ptr_data_type;
24053         TALLOC_CTX *_mem_save_handle_0;
24054         TALLOC_CTX *_mem_save_data_type_0;
24055         TALLOC_CTX *_mem_save_devmode_ctr_0;
24056         if (flags & NDR_IN) {
24057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24058                         NDR_PULL_ALLOC(ndr, r->in.handle);
24059                 }
24060                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24061                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24062                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
24065                 if (_ptr_data_type) {
24066                         NDR_PULL_ALLOC(ndr, r->in.data_type);
24067                 } else {
24068                         r->in.data_type = NULL;
24069                 }
24070                 if (r->in.data_type) {
24071                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24072                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
24073                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
24074                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
24075                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
24076                                 return 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));
24077                         }
24078                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
24079                         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));
24080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
24081                 }
24082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24083                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24084                 }
24085                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24086                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24087                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24089         }
24090         if (flags & NDR_OUT) {
24091                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24092         }
24093         return NDR_ERR_SUCCESS;
24094 }
24095
24096 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
24097 {
24098         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
24099         ndr->depth++;
24100         if (flags & NDR_SET_VALUES) {
24101                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24102         }
24103         if (flags & NDR_IN) {
24104                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
24105                 ndr->depth++;
24106                 ndr_print_ptr(ndr, "handle", r->in.handle);
24107                 ndr->depth++;
24108                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24109                 ndr->depth--;
24110                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
24111                 ndr->depth++;
24112                 if (r->in.data_type) {
24113                         ndr_print_string(ndr, "data_type", r->in.data_type);
24114                 }
24115                 ndr->depth--;
24116                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24117                 ndr->depth++;
24118                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24119                 ndr->depth--;
24120                 ndr->depth--;
24121         }
24122         if (flags & NDR_OUT) {
24123                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
24124                 ndr->depth++;
24125                 ndr_print_WERROR(ndr, "result", r->out.result);
24126                 ndr->depth--;
24127         }
24128         ndr->depth--;
24129 }
24130
24131 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
24132 {
24133         if (flags & NDR_IN) {
24134                 if (r->in.handle == NULL) {
24135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24136                 }
24137                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
24139                 if (r->in.architecture) {
24140                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24143                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24144                 }
24145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24146                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24147                 if (r->in.buffer) {
24148                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24149                 }
24150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24151                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
24152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
24153         }
24154         if (flags & NDR_OUT) {
24155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24156                 if (r->out.info) {
24157                         {
24158                                 struct ndr_push *_ndr_info;
24159                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24160                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24161                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24162                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24163                         }
24164                 }
24165                 if (r->out.needed == NULL) {
24166                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24167                 }
24168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24169                 if (r->out.server_major_version == NULL) {
24170                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24171                 }
24172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24173                 if (r->out.server_minor_version == NULL) {
24174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24175                 }
24176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24177                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24178         }
24179         return NDR_ERR_SUCCESS;
24180 }
24181
24182 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24183 {
24184         uint32_t _ptr_architecture;
24185         uint32_t _ptr_buffer;
24186         uint32_t _ptr_info;
24187         TALLOC_CTX *_mem_save_handle_0;
24188         TALLOC_CTX *_mem_save_architecture_0;
24189         TALLOC_CTX *_mem_save_buffer_0;
24190         TALLOC_CTX *_mem_save_info_0;
24191         TALLOC_CTX *_mem_save_needed_0;
24192         TALLOC_CTX *_mem_save_server_major_version_0;
24193         TALLOC_CTX *_mem_save_server_minor_version_0;
24194         if (flags & NDR_IN) {
24195                 ZERO_STRUCT(r->out);
24196
24197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24198                         NDR_PULL_ALLOC(ndr, r->in.handle);
24199                 }
24200                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24201                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24202                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24204                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24205                 if (_ptr_architecture) {
24206                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24207                 } else {
24208                         r->in.architecture = NULL;
24209                 }
24210                 if (r->in.architecture) {
24211                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24212                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24213                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24214                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24215                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24216                                 return 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));
24217                         }
24218                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24221                 }
24222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24224                 if (_ptr_buffer) {
24225                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24226                 } else {
24227                         r->in.buffer = NULL;
24228                 }
24229                 if (r->in.buffer) {
24230                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24231                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24232                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24234                 }
24235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24238                 NDR_PULL_ALLOC(ndr, r->out.needed);
24239                 ZERO_STRUCTP(r->out.needed);
24240                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24241                 ZERO_STRUCTP(r->out.server_major_version);
24242                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24243                 ZERO_STRUCTP(r->out.server_minor_version);
24244         }
24245         if (flags & NDR_OUT) {
24246                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24247                 if (_ptr_info) {
24248                         NDR_PULL_ALLOC(ndr, r->out.info);
24249                 } else {
24250                         r->out.info = NULL;
24251                 }
24252                 if (r->out.info) {
24253                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24254                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24255                         {
24256                                 struct ndr_pull *_ndr_info;
24257                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24258                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24259                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24260                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24261                         }
24262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24263                 }
24264                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24265                         NDR_PULL_ALLOC(ndr, r->out.needed);
24266                 }
24267                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24268                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24270                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24272                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24273                 }
24274                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24275                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24278                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24279                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24280                 }
24281                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24282                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24284                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24285                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24286         }
24287         return NDR_ERR_SUCCESS;
24288 }
24289
24290 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24291 {
24292         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24293         ndr->depth++;
24294         if (flags & NDR_SET_VALUES) {
24295                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24296         }
24297         if (flags & NDR_IN) {
24298                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24299                 ndr->depth++;
24300                 ndr_print_ptr(ndr, "handle", r->in.handle);
24301                 ndr->depth++;
24302                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24303                 ndr->depth--;
24304                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24305                 ndr->depth++;
24306                 if (r->in.architecture) {
24307                         ndr_print_string(ndr, "architecture", r->in.architecture);
24308                 }
24309                 ndr->depth--;
24310                 ndr_print_uint32(ndr, "level", r->in.level);
24311                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24312                 ndr->depth++;
24313                 if (r->in.buffer) {
24314                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24315                 }
24316                 ndr->depth--;
24317                 ndr_print_uint32(ndr, "offered", r->in.offered);
24318                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24319                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24320                 ndr->depth--;
24321         }
24322         if (flags & NDR_OUT) {
24323                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24324                 ndr->depth++;
24325                 ndr_print_ptr(ndr, "info", r->out.info);
24326                 ndr->depth++;
24327                 if (r->out.info) {
24328                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24329                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24330                 }
24331                 ndr->depth--;
24332                 ndr_print_ptr(ndr, "needed", r->out.needed);
24333                 ndr->depth++;
24334                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24335                 ndr->depth--;
24336                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24337                 ndr->depth++;
24338                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24339                 ndr->depth--;
24340                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24341                 ndr->depth++;
24342                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24343                 ndr->depth--;
24344                 ndr_print_WERROR(ndr, "result", r->out.result);
24345                 ndr->depth--;
24346         }
24347         ndr->depth--;
24348 }
24349
24350 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24351 {
24352         if (flags & NDR_IN) {
24353         }
24354         if (flags & NDR_OUT) {
24355                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24356         }
24357         return NDR_ERR_SUCCESS;
24358 }
24359
24360 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24361 {
24362         if (flags & NDR_IN) {
24363         }
24364         if (flags & NDR_OUT) {
24365                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24366         }
24367         return NDR_ERR_SUCCESS;
24368 }
24369
24370 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24371 {
24372         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24373         ndr->depth++;
24374         if (flags & NDR_SET_VALUES) {
24375                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24376         }
24377         if (flags & NDR_IN) {
24378                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24379                 ndr->depth++;
24380                 ndr->depth--;
24381         }
24382         if (flags & NDR_OUT) {
24383                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24384                 ndr->depth++;
24385                 ndr_print_WERROR(ndr, "result", r->out.result);
24386                 ndr->depth--;
24387         }
24388         ndr->depth--;
24389 }
24390
24391 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24392 {
24393         if (flags & NDR_IN) {
24394         }
24395         if (flags & NDR_OUT) {
24396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24397         }
24398         return NDR_ERR_SUCCESS;
24399 }
24400
24401 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24402 {
24403         if (flags & NDR_IN) {
24404         }
24405         if (flags & NDR_OUT) {
24406                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24407         }
24408         return NDR_ERR_SUCCESS;
24409 }
24410
24411 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24412 {
24413         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24414         ndr->depth++;
24415         if (flags & NDR_SET_VALUES) {
24416                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24417         }
24418         if (flags & NDR_IN) {
24419                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24420                 ndr->depth++;
24421                 ndr->depth--;
24422         }
24423         if (flags & NDR_OUT) {
24424                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24425                 ndr->depth++;
24426                 ndr_print_WERROR(ndr, "result", r->out.result);
24427                 ndr->depth--;
24428         }
24429         ndr->depth--;
24430 }
24431
24432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24433 {
24434         if (flags & NDR_IN) {
24435                 if (r->in.handle == NULL) {
24436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24437                 }
24438                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24439         }
24440         if (flags & NDR_OUT) {
24441                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24442         }
24443         return NDR_ERR_SUCCESS;
24444 }
24445
24446 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24447 {
24448         TALLOC_CTX *_mem_save_handle_0;
24449         if (flags & NDR_IN) {
24450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24451                         NDR_PULL_ALLOC(ndr, r->in.handle);
24452                 }
24453                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24454                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24455                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24457         }
24458         if (flags & NDR_OUT) {
24459                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24460         }
24461         return NDR_ERR_SUCCESS;
24462 }
24463
24464 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24465 {
24466         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24467         ndr->depth++;
24468         if (flags & NDR_SET_VALUES) {
24469                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24470         }
24471         if (flags & NDR_IN) {
24472                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24473                 ndr->depth++;
24474                 ndr_print_ptr(ndr, "handle", r->in.handle);
24475                 ndr->depth++;
24476                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24477                 ndr->depth--;
24478                 ndr->depth--;
24479         }
24480         if (flags & NDR_OUT) {
24481                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24482                 ndr->depth++;
24483                 ndr_print_WERROR(ndr, "result", r->out.result);
24484                 ndr->depth--;
24485         }
24486         ndr->depth--;
24487 }
24488
24489 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24490 {
24491         if (flags & NDR_IN) {
24492         }
24493         if (flags & NDR_OUT) {
24494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24495         }
24496         return NDR_ERR_SUCCESS;
24497 }
24498
24499 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24500 {
24501         if (flags & NDR_IN) {
24502         }
24503         if (flags & NDR_OUT) {
24504                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24505         }
24506         return NDR_ERR_SUCCESS;
24507 }
24508
24509 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24510 {
24511         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24512         ndr->depth++;
24513         if (flags & NDR_SET_VALUES) {
24514                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24515         }
24516         if (flags & NDR_IN) {
24517                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24518                 ndr->depth++;
24519                 ndr->depth--;
24520         }
24521         if (flags & NDR_OUT) {
24522                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24523                 ndr->depth++;
24524                 ndr_print_WERROR(ndr, "result", r->out.result);
24525                 ndr->depth--;
24526         }
24527         ndr->depth--;
24528 }
24529
24530 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24531 {
24532         if (flags & NDR_IN) {
24533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24536                 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));
24537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24538                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24541                 if (r->in.buffer) {
24542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24543                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24544                 }
24545         }
24546         if (flags & NDR_OUT) {
24547                 if (r->out.handle == NULL) {
24548                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24549                 }
24550                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24551                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24552         }
24553         return NDR_ERR_SUCCESS;
24554 }
24555
24556 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24557 {
24558         uint32_t _ptr_buffer;
24559         TALLOC_CTX *_mem_save_buffer_0;
24560         TALLOC_CTX *_mem_save_handle_0;
24561         if (flags & NDR_IN) {
24562                 ZERO_STRUCT(r->out);
24563
24564                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24565                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24566                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24567                         return 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));
24568                 }
24569                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24570                 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));
24571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24572                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24574                 if (r->in.bufsize > 512) {
24575                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24576                 }
24577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24578                 if (_ptr_buffer) {
24579                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24580                 } else {
24581                         r->in.buffer = NULL;
24582                 }
24583                 if (r->in.buffer) {
24584                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24585                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24586                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24587                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24588                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24590                 }
24591                 NDR_PULL_ALLOC(ndr, r->out.handle);
24592                 ZERO_STRUCTP(r->out.handle);
24593                 if (r->in.buffer) {
24594                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24595                 }
24596         }
24597         if (flags & NDR_OUT) {
24598                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24599                         NDR_PULL_ALLOC(ndr, r->out.handle);
24600                 }
24601                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24602                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24603                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24604                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24605                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24606         }
24607         return NDR_ERR_SUCCESS;
24608 }
24609
24610 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24611 {
24612         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24613         ndr->depth++;
24614         if (flags & NDR_SET_VALUES) {
24615                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24616         }
24617         if (flags & NDR_IN) {
24618                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24619                 ndr->depth++;
24620                 ndr_print_string(ndr, "server_name", r->in.server_name);
24621                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24622                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24623                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24624                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24625                 ndr->depth++;
24626                 if (r->in.buffer) {
24627                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24628                 }
24629                 ndr->depth--;
24630                 ndr->depth--;
24631         }
24632         if (flags & NDR_OUT) {
24633                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24634                 ndr->depth++;
24635                 ndr_print_ptr(ndr, "handle", r->out.handle);
24636                 ndr->depth++;
24637                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24638                 ndr->depth--;
24639                 ndr_print_WERROR(ndr, "result", r->out.result);
24640                 ndr->depth--;
24641         }
24642         ndr->depth--;
24643 }
24644
24645 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24646 {
24647         if (flags & NDR_IN) {
24648                 if (r->in.handle == NULL) {
24649                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24650                 }
24651                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24652                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24655                 if (r->in.buffer) {
24656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24657                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24658                 }
24659         }
24660         if (flags & NDR_OUT) {
24661                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24662         }
24663         return NDR_ERR_SUCCESS;
24664 }
24665
24666 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24667 {
24668         uint32_t _ptr_buffer;
24669         TALLOC_CTX *_mem_save_handle_0;
24670         TALLOC_CTX *_mem_save_buffer_0;
24671         if (flags & NDR_IN) {
24672                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24673                         NDR_PULL_ALLOC(ndr, r->in.handle);
24674                 }
24675                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24676                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24677                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24678                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24679                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24681                 if (r->in.bufsize > 512) {
24682                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24683                 }
24684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24685                 if (_ptr_buffer) {
24686                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24687                 } else {
24688                         r->in.buffer = NULL;
24689                 }
24690                 if (r->in.buffer) {
24691                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24692                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24693                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24694                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24695                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24697                 }
24698                 if (r->in.buffer) {
24699                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24700                 }
24701         }
24702         if (flags & NDR_OUT) {
24703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24704         }
24705         return NDR_ERR_SUCCESS;
24706 }
24707
24708 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24709 {
24710         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24711         ndr->depth++;
24712         if (flags & NDR_SET_VALUES) {
24713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24714         }
24715         if (flags & NDR_IN) {
24716                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24717                 ndr->depth++;
24718                 ndr_print_ptr(ndr, "handle", r->in.handle);
24719                 ndr->depth++;
24720                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24721                 ndr->depth--;
24722                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24723                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24724                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24725                 ndr->depth++;
24726                 if (r->in.buffer) {
24727                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24728                 }
24729                 ndr->depth--;
24730                 ndr->depth--;
24731         }
24732         if (flags & NDR_OUT) {
24733                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24734                 ndr->depth++;
24735                 ndr_print_WERROR(ndr, "result", r->out.result);
24736                 ndr->depth--;
24737         }
24738         ndr->depth--;
24739 }
24740
24741 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24742 {
24743         if (flags & NDR_IN) {
24744                 if (r->in.handle == NULL) {
24745                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24746                 }
24747                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24748         }
24749         if (flags & NDR_OUT) {
24750                 if (r->out.handle == NULL) {
24751                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24752                 }
24753                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24754                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24755         }
24756         return NDR_ERR_SUCCESS;
24757 }
24758
24759 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24760 {
24761         TALLOC_CTX *_mem_save_handle_0;
24762         if (flags & NDR_IN) {
24763                 ZERO_STRUCT(r->out);
24764
24765                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24766                         NDR_PULL_ALLOC(ndr, r->in.handle);
24767                 }
24768                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24769                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24770                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24772                 NDR_PULL_ALLOC(ndr, r->out.handle);
24773                 *r->out.handle = *r->in.handle;
24774         }
24775         if (flags & NDR_OUT) {
24776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24777                         NDR_PULL_ALLOC(ndr, r->out.handle);
24778                 }
24779                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24780                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24781                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24783                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24784         }
24785         return NDR_ERR_SUCCESS;
24786 }
24787
24788 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24789 {
24790         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24791         ndr->depth++;
24792         if (flags & NDR_SET_VALUES) {
24793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24794         }
24795         if (flags & NDR_IN) {
24796                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24797                 ndr->depth++;
24798                 ndr_print_ptr(ndr, "handle", r->in.handle);
24799                 ndr->depth++;
24800                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24801                 ndr->depth--;
24802                 ndr->depth--;
24803         }
24804         if (flags & NDR_OUT) {
24805                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24806                 ndr->depth++;
24807                 ndr_print_ptr(ndr, "handle", r->out.handle);
24808                 ndr->depth++;
24809                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24810                 ndr->depth--;
24811                 ndr_print_WERROR(ndr, "result", r->out.result);
24812                 ndr->depth--;
24813         }
24814         ndr->depth--;
24815 }
24816
24817 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24818 {
24819         if (flags & NDR_IN) {
24820         }
24821         if (flags & NDR_OUT) {
24822                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24823         }
24824         return NDR_ERR_SUCCESS;
24825 }
24826
24827 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24828 {
24829         if (flags & NDR_IN) {
24830         }
24831         if (flags & NDR_OUT) {
24832                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24833         }
24834         return NDR_ERR_SUCCESS;
24835 }
24836
24837 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24838 {
24839         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24840         ndr->depth++;
24841         if (flags & NDR_SET_VALUES) {
24842                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24843         }
24844         if (flags & NDR_IN) {
24845                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24846                 ndr->depth++;
24847                 ndr->depth--;
24848         }
24849         if (flags & NDR_OUT) {
24850                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24851                 ndr->depth++;
24852                 ndr_print_WERROR(ndr, "result", r->out.result);
24853                 ndr->depth--;
24854         }
24855         ndr->depth--;
24856 }
24857
24858 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24859 {
24860         if (flags & NDR_IN) {
24861         }
24862         if (flags & NDR_OUT) {
24863                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24864         }
24865         return NDR_ERR_SUCCESS;
24866 }
24867
24868 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24869 {
24870         if (flags & NDR_IN) {
24871         }
24872         if (flags & NDR_OUT) {
24873                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24874         }
24875         return NDR_ERR_SUCCESS;
24876 }
24877
24878 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24879 {
24880         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24881         ndr->depth++;
24882         if (flags & NDR_SET_VALUES) {
24883                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24884         }
24885         if (flags & NDR_IN) {
24886                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24887                 ndr->depth++;
24888                 ndr->depth--;
24889         }
24890         if (flags & NDR_OUT) {
24891                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24892                 ndr->depth++;
24893                 ndr_print_WERROR(ndr, "result", r->out.result);
24894                 ndr->depth--;
24895         }
24896         ndr->depth--;
24897 }
24898
24899 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24900 {
24901         if (flags & NDR_IN) {
24902         }
24903         if (flags & NDR_OUT) {
24904                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24905         }
24906         return NDR_ERR_SUCCESS;
24907 }
24908
24909 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24910 {
24911         if (flags & NDR_IN) {
24912         }
24913         if (flags & NDR_OUT) {
24914                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24915         }
24916         return NDR_ERR_SUCCESS;
24917 }
24918
24919 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24920 {
24921         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24922         ndr->depth++;
24923         if (flags & NDR_SET_VALUES) {
24924                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24925         }
24926         if (flags & NDR_IN) {
24927                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24928                 ndr->depth++;
24929                 ndr->depth--;
24930         }
24931         if (flags & NDR_OUT) {
24932                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24933                 ndr->depth++;
24934                 ndr_print_WERROR(ndr, "result", r->out.result);
24935                 ndr->depth--;
24936         }
24937         ndr->depth--;
24938 }
24939
24940 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24941 {
24942         if (flags & NDR_IN) {
24943         }
24944         if (flags & NDR_OUT) {
24945                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24946         }
24947         return NDR_ERR_SUCCESS;
24948 }
24949
24950 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24951 {
24952         if (flags & NDR_IN) {
24953         }
24954         if (flags & NDR_OUT) {
24955                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24956         }
24957         return NDR_ERR_SUCCESS;
24958 }
24959
24960 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24961 {
24962         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24963         ndr->depth++;
24964         if (flags & NDR_SET_VALUES) {
24965                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24966         }
24967         if (flags & NDR_IN) {
24968                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24969                 ndr->depth++;
24970                 ndr->depth--;
24971         }
24972         if (flags & NDR_OUT) {
24973                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24974                 ndr->depth++;
24975                 ndr_print_WERROR(ndr, "result", r->out.result);
24976                 ndr->depth--;
24977         }
24978         ndr->depth--;
24979 }
24980
24981 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24982 {
24983         if (flags & NDR_IN) {
24984                 if (r->in.handle == NULL) {
24985                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24986                 }
24987                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24988                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24991                 if (r->in.local_machine) {
24992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24995                         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));
24996                 }
24997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24998                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24999                 if (r->in.notify_options) {
25000                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25001                 }
25002         }
25003         if (flags & NDR_OUT) {
25004                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25005         }
25006         return NDR_ERR_SUCCESS;
25007 }
25008
25009 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25010 {
25011         uint32_t _ptr_local_machine;
25012         uint32_t _ptr_notify_options;
25013         TALLOC_CTX *_mem_save_handle_0;
25014         TALLOC_CTX *_mem_save_local_machine_0;
25015         TALLOC_CTX *_mem_save_notify_options_0;
25016         if (flags & NDR_IN) {
25017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25018                         NDR_PULL_ALLOC(ndr, r->in.handle);
25019                 }
25020                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25021                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25022                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25024                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
25026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
25027                 if (_ptr_local_machine) {
25028                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
25029                 } else {
25030                         r->in.local_machine = NULL;
25031                 }
25032                 if (r->in.local_machine) {
25033                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
25034                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
25035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
25036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
25037                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
25038                                 return 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));
25039                         }
25040                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
25041                         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));
25042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
25043                 }
25044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
25046                 if (_ptr_notify_options) {
25047                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
25048                 } else {
25049                         r->in.notify_options = NULL;
25050                 }
25051                 if (r->in.notify_options) {
25052                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25053                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
25054                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
25056                 }
25057         }
25058         if (flags & NDR_OUT) {
25059                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25060         }
25061         return NDR_ERR_SUCCESS;
25062 }
25063
25064 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25065 {
25066         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25067         ndr->depth++;
25068         if (flags & NDR_SET_VALUES) {
25069                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25070         }
25071         if (flags & NDR_IN) {
25072                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25073                 ndr->depth++;
25074                 ndr_print_ptr(ndr, "handle", r->in.handle);
25075                 ndr->depth++;
25076                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25077                 ndr->depth--;
25078                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25079                 ndr_print_uint32(ndr, "options", r->in.options);
25080                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
25081                 ndr->depth++;
25082                 if (r->in.local_machine) {
25083                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
25084                 }
25085                 ndr->depth--;
25086                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25087                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
25088                 ndr->depth++;
25089                 if (r->in.notify_options) {
25090                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
25091                 }
25092                 ndr->depth--;
25093                 ndr->depth--;
25094         }
25095         if (flags & NDR_OUT) {
25096                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25097                 ndr->depth++;
25098                 ndr_print_WERROR(ndr, "result", r->out.result);
25099                 ndr->depth--;
25100         }
25101         ndr->depth--;
25102 }
25103
25104 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25105 {
25106         if (flags & NDR_IN) {
25107                 if (r->in.handle == NULL) {
25108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25109                 }
25110                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
25112                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
25114                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25115                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25116         }
25117         if (flags & NDR_OUT) {
25118                 if (r->out.reply_result == NULL) {
25119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25120                 }
25121                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
25122                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25123         }
25124         return NDR_ERR_SUCCESS;
25125 }
25126
25127 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
25128 {
25129         TALLOC_CTX *_mem_save_handle_0;
25130         TALLOC_CTX *_mem_save_reply_result_0;
25131         if (flags & NDR_IN) {
25132                 ZERO_STRUCT(r->out);
25133
25134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25135                         NDR_PULL_ALLOC(ndr, r->in.handle);
25136                 }
25137                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25138                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25139                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
25142                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
25144                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25145                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25146                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
25147                 ZERO_STRUCTP(r->out.reply_result);
25148         }
25149         if (flags & NDR_OUT) {
25150                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25151                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
25152                 }
25153                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
25154                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
25155                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
25156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
25157                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25158         }
25159         return NDR_ERR_SUCCESS;
25160 }
25161
25162 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25163 {
25164         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
25165         ndr->depth++;
25166         if (flags & NDR_SET_VALUES) {
25167                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25168         }
25169         if (flags & NDR_IN) {
25170                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25171                 ndr->depth++;
25172                 ndr_print_ptr(ndr, "handle", r->in.handle);
25173                 ndr->depth++;
25174                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25175                 ndr->depth--;
25176                 ndr_print_uint32(ndr, "color", r->in.color);
25177                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25178                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25179                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25180                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25181                 ndr->depth--;
25182         }
25183         if (flags & NDR_OUT) {
25184                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25185                 ndr->depth++;
25186                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25187                 ndr->depth++;
25188                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25189                 ndr->depth--;
25190                 ndr_print_WERROR(ndr, "result", r->out.result);
25191                 ndr->depth--;
25192         }
25193         ndr->depth--;
25194 }
25195
25196 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25197 {
25198         if (flags & NDR_IN) {
25199                 if (r->in.handle == NULL) {
25200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25201                 }
25202                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25205                 if (r->in.options) {
25206                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25207                 }
25208         }
25209         if (flags & NDR_OUT) {
25210                 if (r->out.info == NULL) {
25211                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25212                 }
25213                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25214                 if (*r->out.info) {
25215                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25216                 }
25217                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25218         }
25219         return NDR_ERR_SUCCESS;
25220 }
25221
25222 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25223 {
25224         uint32_t _ptr_options;
25225         uint32_t _ptr_info;
25226         TALLOC_CTX *_mem_save_handle_0;
25227         TALLOC_CTX *_mem_save_options_0;
25228         TALLOC_CTX *_mem_save_info_0;
25229         TALLOC_CTX *_mem_save_info_1;
25230         if (flags & NDR_IN) {
25231                 ZERO_STRUCT(r->out);
25232
25233                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25234                         NDR_PULL_ALLOC(ndr, r->in.handle);
25235                 }
25236                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25237                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25238                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25239                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25242                 if (_ptr_options) {
25243                         NDR_PULL_ALLOC(ndr, r->in.options);
25244                 } else {
25245                         r->in.options = NULL;
25246                 }
25247                 if (r->in.options) {
25248                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25249                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25250                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25252                 }
25253                 NDR_PULL_ALLOC(ndr, r->out.info);
25254                 ZERO_STRUCTP(r->out.info);
25255         }
25256         if (flags & NDR_OUT) {
25257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25258                         NDR_PULL_ALLOC(ndr, r->out.info);
25259                 }
25260                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25261                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25263                 if (_ptr_info) {
25264                         NDR_PULL_ALLOC(ndr, *r->out.info);
25265                 } else {
25266                         *r->out.info = NULL;
25267                 }
25268                 if (*r->out.info) {
25269                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25270                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25271                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25273                 }
25274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25275                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25276         }
25277         return NDR_ERR_SUCCESS;
25278 }
25279
25280 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25281 {
25282         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25283         ndr->depth++;
25284         if (flags & NDR_SET_VALUES) {
25285                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25286         }
25287         if (flags & NDR_IN) {
25288                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25289                 ndr->depth++;
25290                 ndr_print_ptr(ndr, "handle", r->in.handle);
25291                 ndr->depth++;
25292                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25293                 ndr->depth--;
25294                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25295                 ndr_print_ptr(ndr, "options", r->in.options);
25296                 ndr->depth++;
25297                 if (r->in.options) {
25298                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25299                 }
25300                 ndr->depth--;
25301                 ndr->depth--;
25302         }
25303         if (flags & NDR_OUT) {
25304                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25305                 ndr->depth++;
25306                 ndr_print_ptr(ndr, "info", r->out.info);
25307                 ndr->depth++;
25308                 ndr_print_ptr(ndr, "info", *r->out.info);
25309                 ndr->depth++;
25310                 if (*r->out.info) {
25311                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25312                 }
25313                 ndr->depth--;
25314                 ndr->depth--;
25315                 ndr_print_WERROR(ndr, "result", r->out.result);
25316                 ndr->depth--;
25317         }
25318         ndr->depth--;
25319 }
25320
25321 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25322 {
25323         if (flags & NDR_IN) {
25324         }
25325         if (flags & NDR_OUT) {
25326                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25327         }
25328         return NDR_ERR_SUCCESS;
25329 }
25330
25331 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25332 {
25333         if (flags & NDR_IN) {
25334         }
25335         if (flags & NDR_OUT) {
25336                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25337         }
25338         return NDR_ERR_SUCCESS;
25339 }
25340
25341 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25342 {
25343         ndr_print_struct(ndr, name, "spoolss_44");
25344         ndr->depth++;
25345         if (flags & NDR_SET_VALUES) {
25346                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25347         }
25348         if (flags & NDR_IN) {
25349                 ndr_print_struct(ndr, "in", "spoolss_44");
25350                 ndr->depth++;
25351                 ndr->depth--;
25352         }
25353         if (flags & NDR_OUT) {
25354                 ndr_print_struct(ndr, "out", "spoolss_44");
25355                 ndr->depth++;
25356                 ndr_print_WERROR(ndr, "result", r->out.result);
25357                 ndr->depth--;
25358         }
25359         ndr->depth--;
25360 }
25361
25362 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25363 {
25364         if (flags & NDR_IN) {
25365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25366                 if (r->in.printername) {
25367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25371                 }
25372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25373                 if (r->in.datatype) {
25374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25378                 }
25379                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25380                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25382                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25383                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25384         }
25385         if (flags & NDR_OUT) {
25386                 if (r->out.handle == NULL) {
25387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25388                 }
25389                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25390                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25391         }
25392         return NDR_ERR_SUCCESS;
25393 }
25394
25395 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25396 {
25397         uint32_t _ptr_printername;
25398         uint32_t _ptr_datatype;
25399         TALLOC_CTX *_mem_save_printername_0;
25400         TALLOC_CTX *_mem_save_datatype_0;
25401         TALLOC_CTX *_mem_save_handle_0;
25402         if (flags & NDR_IN) {
25403                 ZERO_STRUCT(r->out);
25404
25405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25406                 if (_ptr_printername) {
25407                         NDR_PULL_ALLOC(ndr, r->in.printername);
25408                 } else {
25409                         r->in.printername = NULL;
25410                 }
25411                 if (r->in.printername) {
25412                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25413                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25416                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25417                                 return 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));
25418                         }
25419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25422                 }
25423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25424                 if (_ptr_datatype) {
25425                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25426                 } else {
25427                         r->in.datatype = NULL;
25428                 }
25429                 if (r->in.datatype) {
25430                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25431                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25432                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25433                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25434                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25435                                 return 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));
25436                         }
25437                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25438                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25440                 }
25441                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25442                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25444                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25445                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25446                 NDR_PULL_ALLOC(ndr, r->out.handle);
25447                 ZERO_STRUCTP(r->out.handle);
25448         }
25449         if (flags & NDR_OUT) {
25450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25451                         NDR_PULL_ALLOC(ndr, r->out.handle);
25452                 }
25453                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25454                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25455                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25457                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25458         }
25459         return NDR_ERR_SUCCESS;
25460 }
25461
25462 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25463 {
25464         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25465         ndr->depth++;
25466         if (flags & NDR_SET_VALUES) {
25467                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25468         }
25469         if (flags & NDR_IN) {
25470                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25471                 ndr->depth++;
25472                 ndr_print_ptr(ndr, "printername", r->in.printername);
25473                 ndr->depth++;
25474                 if (r->in.printername) {
25475                         ndr_print_string(ndr, "printername", r->in.printername);
25476                 }
25477                 ndr->depth--;
25478                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25479                 ndr->depth++;
25480                 if (r->in.datatype) {
25481                         ndr_print_string(ndr, "datatype", r->in.datatype);
25482                 }
25483                 ndr->depth--;
25484                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25485                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25486                 ndr_print_uint32(ndr, "level", r->in.level);
25487                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25488                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25489                 ndr->depth--;
25490         }
25491         if (flags & NDR_OUT) {
25492                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25493                 ndr->depth++;
25494                 ndr_print_ptr(ndr, "handle", r->out.handle);
25495                 ndr->depth++;
25496                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25497                 ndr->depth--;
25498                 ndr_print_WERROR(ndr, "result", r->out.result);
25499                 ndr->depth--;
25500         }
25501         ndr->depth--;
25502 }
25503
25504 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25505 {
25506         if (flags & NDR_IN) {
25507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25508                 if (r->in.server) {
25509                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25510                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25513                 }
25514                 if (r->in.info_ctr == NULL) {
25515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25516                 }
25517                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25518                 if (r->in.devmode_ctr == NULL) {
25519                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25520                 }
25521                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25522                 if (r->in.secdesc_ctr == NULL) {
25523                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25524                 }
25525                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25526                 if (r->in.userlevel_ctr == NULL) {
25527                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25528                 }
25529                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25530         }
25531         if (flags & NDR_OUT) {
25532                 if (r->out.handle == NULL) {
25533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25534                 }
25535                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25536                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25537         }
25538         return NDR_ERR_SUCCESS;
25539 }
25540
25541 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25542 {
25543         uint32_t _ptr_server;
25544         TALLOC_CTX *_mem_save_server_0;
25545         TALLOC_CTX *_mem_save_info_ctr_0;
25546         TALLOC_CTX *_mem_save_devmode_ctr_0;
25547         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25548         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25549         TALLOC_CTX *_mem_save_handle_0;
25550         if (flags & NDR_IN) {
25551                 ZERO_STRUCT(r->out);
25552
25553                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25554                 if (_ptr_server) {
25555                         NDR_PULL_ALLOC(ndr, r->in.server);
25556                 } else {
25557                         r->in.server = NULL;
25558                 }
25559                 if (r->in.server) {
25560                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25561                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25564                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25565                                 return 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));
25566                         }
25567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25568                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25570                 }
25571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25572                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25573                 }
25574                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25575                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25576                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25578                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25579                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25580                 }
25581                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25582                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25583                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25584                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25585                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25586                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25587                 }
25588                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25589                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25590                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25592                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25593                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25594                 }
25595                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25596                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25597                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25599                 NDR_PULL_ALLOC(ndr, r->out.handle);
25600                 ZERO_STRUCTP(r->out.handle);
25601         }
25602         if (flags & NDR_OUT) {
25603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25604                         NDR_PULL_ALLOC(ndr, r->out.handle);
25605                 }
25606                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25607                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25608                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25610                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25611         }
25612         return NDR_ERR_SUCCESS;
25613 }
25614
25615 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25616 {
25617         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25618         ndr->depth++;
25619         if (flags & NDR_SET_VALUES) {
25620                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25621         }
25622         if (flags & NDR_IN) {
25623                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25624                 ndr->depth++;
25625                 ndr_print_ptr(ndr, "server", r->in.server);
25626                 ndr->depth++;
25627                 if (r->in.server) {
25628                         ndr_print_string(ndr, "server", r->in.server);
25629                 }
25630                 ndr->depth--;
25631                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25632                 ndr->depth++;
25633                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25634                 ndr->depth--;
25635                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25636                 ndr->depth++;
25637                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25638                 ndr->depth--;
25639                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25640                 ndr->depth++;
25641                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25642                 ndr->depth--;
25643                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25644                 ndr->depth++;
25645                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25646                 ndr->depth--;
25647                 ndr->depth--;
25648         }
25649         if (flags & NDR_OUT) {
25650                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25651                 ndr->depth++;
25652                 ndr_print_ptr(ndr, "handle", r->out.handle);
25653                 ndr->depth++;
25654                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25655                 ndr->depth--;
25656                 ndr_print_WERROR(ndr, "result", r->out.result);
25657                 ndr->depth--;
25658         }
25659         ndr->depth--;
25660 }
25661
25662 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25663 {
25664         if (flags & NDR_IN) {
25665         }
25666         if (flags & NDR_OUT) {
25667                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25668         }
25669         return NDR_ERR_SUCCESS;
25670 }
25671
25672 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25673 {
25674         if (flags & NDR_IN) {
25675         }
25676         if (flags & NDR_OUT) {
25677                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25678         }
25679         return NDR_ERR_SUCCESS;
25680 }
25681
25682 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25683 {
25684         ndr_print_struct(ndr, name, "spoolss_47");
25685         ndr->depth++;
25686         if (flags & NDR_SET_VALUES) {
25687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25688         }
25689         if (flags & NDR_IN) {
25690                 ndr_print_struct(ndr, "in", "spoolss_47");
25691                 ndr->depth++;
25692                 ndr->depth--;
25693         }
25694         if (flags & NDR_OUT) {
25695                 ndr_print_struct(ndr, "out", "spoolss_47");
25696                 ndr->depth++;
25697                 ndr_print_WERROR(ndr, "result", r->out.result);
25698                 ndr->depth--;
25699         }
25700         ndr->depth--;
25701 }
25702
25703 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25704 {
25705         if (flags & NDR_IN) {
25706                 if (r->in.handle == NULL) {
25707                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25708                 }
25709                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25713         }
25714         if (flags & NDR_OUT) {
25715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25716                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25717                 if (r->out.value_needed == NULL) {
25718                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25719                 }
25720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25721                 if (r->out.type == NULL) {
25722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25723                 }
25724                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
25725                 {
25726                         uint32_t _flags_save_uint8 = ndr->flags;
25727                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25728                         if (r->out.data == NULL) {
25729                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25730                         }
25731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25732                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
25733                         ndr->flags = _flags_save_uint8;
25734                 }
25735                 if (r->out.data_needed == NULL) {
25736                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25737                 }
25738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25739                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25740         }
25741         return NDR_ERR_SUCCESS;
25742 }
25743
25744 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25745 {
25746         TALLOC_CTX *_mem_save_handle_0;
25747         TALLOC_CTX *_mem_save_value_needed_0;
25748         TALLOC_CTX *_mem_save_type_0;
25749         TALLOC_CTX *_mem_save_data_needed_0;
25750         if (flags & NDR_IN) {
25751                 ZERO_STRUCT(r->out);
25752
25753                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25754                         NDR_PULL_ALLOC(ndr, r->in.handle);
25755                 }
25756                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25757                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25758                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25759                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25760                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25763                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25764                 ZERO_STRUCTP(r->out.value_needed);
25765                 NDR_PULL_ALLOC(ndr, r->out.type);
25766                 ZERO_STRUCTP(r->out.type);
25767                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
25768                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
25769                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25770                 ZERO_STRUCTP(r->out.data_needed);
25771         }
25772         if (flags & NDR_OUT) {
25773                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25774                 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));
25775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25776                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25777                 }
25778                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25779                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25782                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25783                         NDR_PULL_ALLOC(ndr, r->out.type);
25784                 }
25785                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25786                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
25787                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
25788                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
25789                 {
25790                         uint32_t _flags_save_uint8 = ndr->flags;
25791                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
25793                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25794                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
25795                         }
25796                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
25797                         ndr->flags = _flags_save_uint8;
25798                 }
25799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25800                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25801                 }
25802                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25803                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25806                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25807                 if (r->out.value_name) {
25808                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25809                 }
25810                 if (r->out.data) {
25811                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
25812                 }
25813         }
25814         return NDR_ERR_SUCCESS;
25815 }
25816
25817 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25818 {
25819         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25820         ndr->depth++;
25821         if (flags & NDR_SET_VALUES) {
25822                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25823         }
25824         if (flags & NDR_IN) {
25825                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25826                 ndr->depth++;
25827                 ndr_print_ptr(ndr, "handle", r->in.handle);
25828                 ndr->depth++;
25829                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25830                 ndr->depth--;
25831                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25832                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25833                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25834                 ndr->depth--;
25835         }
25836         if (flags & NDR_OUT) {
25837                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25838                 ndr->depth++;
25839                 ndr_print_string(ndr, "value_name", r->out.value_name);
25840                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25841                 ndr->depth++;
25842                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25843                 ndr->depth--;
25844                 ndr_print_ptr(ndr, "type", r->out.type);
25845                 ndr->depth++;
25846                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
25847                 ndr->depth--;
25848                 ndr_print_ptr(ndr, "data", r->out.data);
25849                 ndr->depth++;
25850                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
25851                 ndr->depth--;
25852                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25853                 ndr->depth++;
25854                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25855                 ndr->depth--;
25856                 ndr_print_WERROR(ndr, "result", r->out.result);
25857                 ndr->depth--;
25858         }
25859         ndr->depth--;
25860 }
25861
25862 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25863 {
25864         if (flags & NDR_IN) {
25865                 if (r->in.handle == NULL) {
25866                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25867                 }
25868                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25871                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25872                 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));
25873         }
25874         if (flags & NDR_OUT) {
25875                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25876         }
25877         return NDR_ERR_SUCCESS;
25878 }
25879
25880 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25881 {
25882         TALLOC_CTX *_mem_save_handle_0;
25883         if (flags & NDR_IN) {
25884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25885                         NDR_PULL_ALLOC(ndr, r->in.handle);
25886                 }
25887                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25888                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25889                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25891                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25892                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25893                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25894                         return 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));
25895                 }
25896                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25897                 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));
25898         }
25899         if (flags & NDR_OUT) {
25900                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25901         }
25902         return NDR_ERR_SUCCESS;
25903 }
25904
25905 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25906 {
25907         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
25908         ndr->depth++;
25909         if (flags & NDR_SET_VALUES) {
25910                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25911         }
25912         if (flags & NDR_IN) {
25913                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
25914                 ndr->depth++;
25915                 ndr_print_ptr(ndr, "handle", r->in.handle);
25916                 ndr->depth++;
25917                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25918                 ndr->depth--;
25919                 ndr_print_string(ndr, "value_name", r->in.value_name);
25920                 ndr->depth--;
25921         }
25922         if (flags & NDR_OUT) {
25923                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
25924                 ndr->depth++;
25925                 ndr_print_WERROR(ndr, "result", r->out.result);
25926                 ndr->depth--;
25927         }
25928         ndr->depth--;
25929 }
25930
25931 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
25932 {
25933         if (flags & NDR_IN) {
25934         }
25935         if (flags & NDR_OUT) {
25936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25937         }
25938         return NDR_ERR_SUCCESS;
25939 }
25940
25941 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
25942 {
25943         if (flags & NDR_IN) {
25944         }
25945         if (flags & NDR_OUT) {
25946                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25947         }
25948         return NDR_ERR_SUCCESS;
25949 }
25950
25951 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25952 {
25953         ndr_print_struct(ndr, name, "spoolss_4a");
25954         ndr->depth++;
25955         if (flags & NDR_SET_VALUES) {
25956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25957         }
25958         if (flags & NDR_IN) {
25959                 ndr_print_struct(ndr, "in", "spoolss_4a");
25960                 ndr->depth++;
25961                 ndr->depth--;
25962         }
25963         if (flags & NDR_OUT) {
25964                 ndr_print_struct(ndr, "out", "spoolss_4a");
25965                 ndr->depth++;
25966                 ndr_print_WERROR(ndr, "result", r->out.result);
25967                 ndr->depth--;
25968         }
25969         ndr->depth--;
25970 }
25971
25972 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25973 {
25974         if (flags & NDR_IN) {
25975         }
25976         if (flags & NDR_OUT) {
25977                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25978         }
25979         return NDR_ERR_SUCCESS;
25980 }
25981
25982 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25983 {
25984         if (flags & NDR_IN) {
25985         }
25986         if (flags & NDR_OUT) {
25987                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25988         }
25989         return NDR_ERR_SUCCESS;
25990 }
25991
25992 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25993 {
25994         ndr_print_struct(ndr, name, "spoolss_4b");
25995         ndr->depth++;
25996         if (flags & NDR_SET_VALUES) {
25997                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25998         }
25999         if (flags & NDR_IN) {
26000                 ndr_print_struct(ndr, "in", "spoolss_4b");
26001                 ndr->depth++;
26002                 ndr->depth--;
26003         }
26004         if (flags & NDR_OUT) {
26005                 ndr_print_struct(ndr, "out", "spoolss_4b");
26006                 ndr->depth++;
26007                 ndr_print_WERROR(ndr, "result", r->out.result);
26008                 ndr->depth--;
26009         }
26010         ndr->depth--;
26011 }
26012
26013 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
26014 {
26015         if (flags & NDR_IN) {
26016         }
26017         if (flags & NDR_OUT) {
26018                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26019         }
26020         return NDR_ERR_SUCCESS;
26021 }
26022
26023 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
26024 {
26025         if (flags & NDR_IN) {
26026         }
26027         if (flags & NDR_OUT) {
26028                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26029         }
26030         return NDR_ERR_SUCCESS;
26031 }
26032
26033 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
26034 {
26035         ndr_print_struct(ndr, name, "spoolss_4c");
26036         ndr->depth++;
26037         if (flags & NDR_SET_VALUES) {
26038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26039         }
26040         if (flags & NDR_IN) {
26041                 ndr_print_struct(ndr, "in", "spoolss_4c");
26042                 ndr->depth++;
26043                 ndr->depth--;
26044         }
26045         if (flags & NDR_OUT) {
26046                 ndr_print_struct(ndr, "out", "spoolss_4c");
26047                 ndr->depth++;
26048                 ndr_print_WERROR(ndr, "result", r->out.result);
26049                 ndr->depth--;
26050         }
26051         ndr->depth--;
26052 }
26053
26054 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
26055 {
26056         if (flags & NDR_IN) {
26057                 if (r->in.handle == NULL) {
26058                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26059                 }
26060                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26064                 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));
26065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26068                 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));
26069                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26070                 if (r->in.buffer == NULL) {
26071                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26072                 }
26073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26074                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
26075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26076         }
26077         if (flags & NDR_OUT) {
26078                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26079         }
26080         return NDR_ERR_SUCCESS;
26081 }
26082
26083 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
26084 {
26085         TALLOC_CTX *_mem_save_handle_0;
26086         if (flags & NDR_IN) {
26087                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26088                         NDR_PULL_ALLOC(ndr, r->in.handle);
26089                 }
26090                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26092                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26093                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26094                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26095                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26096                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26097                         return 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));
26098                 }
26099                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26100                 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));
26101                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26102                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26103                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26104                         return 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));
26105                 }
26106                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26107                 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));
26108                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26109                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26111                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26112                 }
26113                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26115                 if (r->in.buffer) {
26116                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
26117                 }
26118         }
26119         if (flags & NDR_OUT) {
26120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26121         }
26122         return NDR_ERR_SUCCESS;
26123 }
26124
26125 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
26126 {
26127         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
26128         ndr->depth++;
26129         if (flags & NDR_SET_VALUES) {
26130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26131         }
26132         if (flags & NDR_IN) {
26133                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
26134                 ndr->depth++;
26135                 ndr_print_ptr(ndr, "handle", r->in.handle);
26136                 ndr->depth++;
26137                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26138                 ndr->depth--;
26139                 ndr_print_string(ndr, "key_name", r->in.key_name);
26140                 ndr_print_string(ndr, "value_name", r->in.value_name);
26141                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26142                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26143                 ndr->depth++;
26144                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
26145                 ndr->depth--;
26146                 ndr_print_uint32(ndr, "offered", r->in.offered);
26147                 ndr->depth--;
26148         }
26149         if (flags & NDR_OUT) {
26150                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
26151                 ndr->depth++;
26152                 ndr_print_WERROR(ndr, "result", r->out.result);
26153                 ndr->depth--;
26154         }
26155         ndr->depth--;
26156 }
26157
26158 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
26159 {
26160         if (flags & NDR_IN) {
26161                 if (r->in.handle == NULL) {
26162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26163                 }
26164                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26168                 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));
26169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26172                 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));
26173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26174         }
26175         if (flags & NDR_OUT) {
26176                 if (r->out.type == NULL) {
26177                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26178                 }
26179                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26180                 if (r->out.buffer == NULL) {
26181                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26182                 }
26183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26184                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26185                 if (r->out.needed == NULL) {
26186                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26187                 }
26188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26189                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26190         }
26191         return NDR_ERR_SUCCESS;
26192 }
26193
26194 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26195 {
26196         TALLOC_CTX *_mem_save_handle_0;
26197         TALLOC_CTX *_mem_save_type_0;
26198         TALLOC_CTX *_mem_save_needed_0;
26199         if (flags & NDR_IN) {
26200                 ZERO_STRUCT(r->out);
26201
26202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26203                         NDR_PULL_ALLOC(ndr, r->in.handle);
26204                 }
26205                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26207                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26209                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26210                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26211                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26212                         return 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));
26213                 }
26214                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26215                 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));
26216                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26217                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26218                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26219                         return 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));
26220                 }
26221                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26222                 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));
26223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26224                 NDR_PULL_ALLOC(ndr, r->out.type);
26225                 ZERO_STRUCTP(r->out.type);
26226                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26227                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26228                 NDR_PULL_ALLOC(ndr, r->out.needed);
26229                 ZERO_STRUCTP(r->out.needed);
26230         }
26231         if (flags & NDR_OUT) {
26232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26233                         NDR_PULL_ALLOC(ndr, r->out.type);
26234                 }
26235                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26236                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26237                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26239                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26240                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26241                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26242                 }
26243                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26244                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26245                         NDR_PULL_ALLOC(ndr, r->out.needed);
26246                 }
26247                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26248                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26251                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26252                 if (r->out.buffer) {
26253                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26254                 }
26255         }
26256         return NDR_ERR_SUCCESS;
26257 }
26258
26259 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26260 {
26261         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26262         ndr->depth++;
26263         if (flags & NDR_SET_VALUES) {
26264                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26265         }
26266         if (flags & NDR_IN) {
26267                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26268                 ndr->depth++;
26269                 ndr_print_ptr(ndr, "handle", r->in.handle);
26270                 ndr->depth++;
26271                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26272                 ndr->depth--;
26273                 ndr_print_string(ndr, "key_name", r->in.key_name);
26274                 ndr_print_string(ndr, "value_name", r->in.value_name);
26275                 ndr_print_uint32(ndr, "offered", r->in.offered);
26276                 ndr->depth--;
26277         }
26278         if (flags & NDR_OUT) {
26279                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26280                 ndr->depth++;
26281                 ndr_print_ptr(ndr, "type", r->out.type);
26282                 ndr->depth++;
26283                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26284                 ndr->depth--;
26285                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26286                 ndr->depth++;
26287                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26288                 ndr->depth--;
26289                 ndr_print_ptr(ndr, "needed", r->out.needed);
26290                 ndr->depth++;
26291                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26292                 ndr->depth--;
26293                 ndr_print_WERROR(ndr, "result", r->out.result);
26294                 ndr->depth--;
26295         }
26296         ndr->depth--;
26297 }
26298
26299 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
26300 {
26301         if (flags & NDR_IN) {
26302                 if (r->in.handle == NULL) {
26303                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26304                 }
26305                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26309                 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));
26310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26311         }
26312         if (flags & NDR_OUT) {
26313                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26314                 if (r->out.needed == NULL) {
26315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26316                 }
26317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26318                 if (r->out.count == NULL) {
26319                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26320                 }
26321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26322                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26323         }
26324         return NDR_ERR_SUCCESS;
26325 }
26326
26327 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
26328 {
26329         TALLOC_CTX *_mem_save_handle_0;
26330         TALLOC_CTX *_mem_save_needed_0;
26331         TALLOC_CTX *_mem_save_count_0;
26332         if (flags & NDR_IN) {
26333                 ZERO_STRUCT(r->out);
26334
26335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26336                         NDR_PULL_ALLOC(ndr, r->in.handle);
26337                 }
26338                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26339                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26340                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26341                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26342                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26343                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26344                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26345                         return 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));
26346                 }
26347                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26348                 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));
26349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26350                 NDR_PULL_ALLOC(ndr, r->out.needed);
26351                 ZERO_STRUCTP(r->out.needed);
26352                 NDR_PULL_ALLOC(ndr, r->out.count);
26353                 ZERO_STRUCTP(r->out.count);
26354         }
26355         if (flags & NDR_OUT) {
26356                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
26357                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26358                         NDR_PULL_ALLOC(ndr, r->out.needed);
26359                 }
26360                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26361                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26365                         NDR_PULL_ALLOC(ndr, r->out.count);
26366                 }
26367                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26368                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26371                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26372         }
26373         return NDR_ERR_SUCCESS;
26374 }
26375
26376 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
26377 {
26378         uint32_t cntr_info_0;
26379         if (flags & NDR_IN) {
26380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26381         }
26382         if (flags & NDR_OUT) {
26383                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26384                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26385                 }
26386                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26387                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26388                 }
26389         }
26390         return NDR_ERR_SUCCESS;
26391 }
26392
26393 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
26394 {
26395         uint32_t cntr_info_0;
26396         TALLOC_CTX *_mem_save_info_0;
26397         if (flags & NDR_IN) {
26398                 ZERO_STRUCT(r->out);
26399
26400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26401         }
26402         if (flags & NDR_OUT) {
26403                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26404                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26405                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26406                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26407                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26408                 }
26409                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26410                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26411                 }
26412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26413         }
26414         return NDR_ERR_SUCCESS;
26415 }
26416
26417 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26418 {
26419         uint32_t cntr_info_2;
26420         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26421         ndr->depth++;
26422         if (flags & NDR_SET_VALUES) {
26423                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26424         }
26425         if (flags & NDR_IN) {
26426                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26427                 ndr->depth++;
26428                 ndr_print_ptr(ndr, "handle", r->in.handle);
26429                 ndr->depth++;
26430                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26431                 ndr->depth--;
26432                 ndr_print_string(ndr, "key_name", r->in.key_name);
26433                 ndr_print_uint32(ndr, "offered", r->in.offered);
26434                 ndr->depth--;
26435         }
26436         if (flags & NDR_OUT) {
26437                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26438                 ndr->depth++;
26439                 ndr_print_ptr(ndr, "count", r->out.count);
26440                 ndr->depth++;
26441                 ndr_print_uint32(ndr, "count", *r->out.count);
26442                 ndr->depth--;
26443                 ndr_print_ptr(ndr, "info", r->out.info);
26444                 ndr->depth++;
26445                 ndr_print_ptr(ndr, "info", *r->out.info);
26446                 ndr->depth++;
26447                 if (*r->out.info) {
26448                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26449                         ndr->depth++;
26450                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26451                                 char *idx_2=NULL;
26452                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26453                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
26454                                         free(idx_2);
26455                                 }
26456                         }
26457                         ndr->depth--;
26458                 }
26459                 ndr->depth--;
26460                 ndr->depth--;
26461                 ndr_print_ptr(ndr, "needed", r->out.needed);
26462                 ndr->depth++;
26463                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26464                 ndr->depth--;
26465                 ndr_print_WERROR(ndr, "result", r->out.result);
26466                 ndr->depth--;
26467         }
26468         ndr->depth--;
26469 }
26470
26471 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26472 {
26473         if (flags & NDR_IN) {
26474                 if (r->in.handle == NULL) {
26475                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26476                 }
26477                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26481                 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));
26482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26483         }
26484         if (flags & NDR_OUT) {
26485                 {
26486                         uint32_t _flags_save_string_array = ndr->flags;
26487                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26488                         if (r->out.key_buffer == NULL) {
26489                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26490                         }
26491                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_buffer));
26492                         if (*r->out.key_buffer) {
26493                                 {
26494                                         struct ndr_push *_ndr_key_buffer;
26495                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26496                                         NDR_CHECK(ndr_push_string_array(_ndr_key_buffer, NDR_SCALARS, *r->out.key_buffer));
26497                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26498                                 }
26499                         }
26500                         ndr->flags = _flags_save_string_array;
26501                 }
26502                 if (r->out.needed == NULL) {
26503                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26504                 }
26505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26506                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26507         }
26508         return NDR_ERR_SUCCESS;
26509 }
26510
26511 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26512 {
26513         uint32_t _ptr_key_buffer;
26514         TALLOC_CTX *_mem_save_handle_0;
26515         TALLOC_CTX *_mem_save_key_buffer_0;
26516         TALLOC_CTX *_mem_save_key_buffer_1;
26517         TALLOC_CTX *_mem_save_needed_0;
26518         if (flags & NDR_IN) {
26519                 ZERO_STRUCT(r->out);
26520
26521                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26522                         NDR_PULL_ALLOC(ndr, r->in.handle);
26523                 }
26524                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26525                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26526                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26528                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26529                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26530                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26531                         return 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));
26532                 }
26533                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26534                 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));
26535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26536                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26537                 ZERO_STRUCTP(r->out.key_buffer);
26538                 NDR_PULL_ALLOC(ndr, r->out.needed);
26539                 ZERO_STRUCTP(r->out.needed);
26540         }
26541         if (flags & NDR_OUT) {
26542                 {
26543                         uint32_t _flags_save_string_array = ndr->flags;
26544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26545                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26546                                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26547                         }
26548                         _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26549                         NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
26550                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_buffer));
26551                         if (_ptr_key_buffer) {
26552                                 NDR_PULL_ALLOC(ndr, *r->out.key_buffer);
26553                         } else {
26554                                 *r->out.key_buffer = NULL;
26555                         }
26556                         if (*r->out.key_buffer) {
26557                                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26558                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_buffer, 0);
26559                                 {
26560                                         struct ndr_pull *_ndr_key_buffer;
26561                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26562                                         NDR_CHECK(ndr_pull_string_array(_ndr_key_buffer, NDR_SCALARS, r->out.key_buffer));
26563                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26564                                 }
26565                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26566                         }
26567                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
26568                         ndr->flags = _flags_save_string_array;
26569                 }
26570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26571                         NDR_PULL_ALLOC(ndr, r->out.needed);
26572                 }
26573                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26574                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26577                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26578         }
26579         return NDR_ERR_SUCCESS;
26580 }
26581
26582 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26583 {
26584         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26585         ndr->depth++;
26586         if (flags & NDR_SET_VALUES) {
26587                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26588         }
26589         if (flags & NDR_IN) {
26590                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26591                 ndr->depth++;
26592                 ndr_print_ptr(ndr, "handle", r->in.handle);
26593                 ndr->depth++;
26594                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26595                 ndr->depth--;
26596                 ndr_print_string(ndr, "key_name", r->in.key_name);
26597                 ndr_print_uint32(ndr, "offered", r->in.offered);
26598                 ndr->depth--;
26599         }
26600         if (flags & NDR_OUT) {
26601                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26602                 ndr->depth++;
26603                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26604                 ndr->depth++;
26605                 ndr_print_ptr(ndr, "key_buffer", *r->out.key_buffer);
26606                 ndr->depth++;
26607                 if (*r->out.key_buffer) {
26608                         ndr_print_string_array(ndr, "key_buffer", *r->out.key_buffer);
26609                 }
26610                 ndr->depth--;
26611                 ndr->depth--;
26612                 ndr_print_ptr(ndr, "needed", r->out.needed);
26613                 ndr->depth++;
26614                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26615                 ndr->depth--;
26616                 ndr_print_WERROR(ndr, "result", r->out.result);
26617                 ndr->depth--;
26618         }
26619         ndr->depth--;
26620 }
26621
26622 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26623 {
26624         if (flags & NDR_IN) {
26625                 if (r->in.handle == NULL) {
26626                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26627                 }
26628                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26632                 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));
26633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26636                 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));
26637         }
26638         if (flags & NDR_OUT) {
26639                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26640         }
26641         return NDR_ERR_SUCCESS;
26642 }
26643
26644 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26645 {
26646         TALLOC_CTX *_mem_save_handle_0;
26647         if (flags & NDR_IN) {
26648                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26649                         NDR_PULL_ALLOC(ndr, r->in.handle);
26650                 }
26651                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26652                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26653                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26654                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26655                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26656                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26657                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26658                         return 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));
26659                 }
26660                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26661                 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));
26662                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26663                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26664                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26665                         return 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));
26666                 }
26667                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26668                 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));
26669         }
26670         if (flags & NDR_OUT) {
26671                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26672         }
26673         return NDR_ERR_SUCCESS;
26674 }
26675
26676 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26677 {
26678         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26679         ndr->depth++;
26680         if (flags & NDR_SET_VALUES) {
26681                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26682         }
26683         if (flags & NDR_IN) {
26684                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26685                 ndr->depth++;
26686                 ndr_print_ptr(ndr, "handle", r->in.handle);
26687                 ndr->depth++;
26688                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26689                 ndr->depth--;
26690                 ndr_print_string(ndr, "key_name", r->in.key_name);
26691                 ndr_print_string(ndr, "value_name", r->in.value_name);
26692                 ndr->depth--;
26693         }
26694         if (flags & NDR_OUT) {
26695                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26696                 ndr->depth++;
26697                 ndr_print_WERROR(ndr, "result", r->out.result);
26698                 ndr->depth--;
26699         }
26700         ndr->depth--;
26701 }
26702
26703 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26704 {
26705         if (flags & NDR_IN) {
26706                 if (r->in.handle == NULL) {
26707                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26708                 }
26709                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26713                 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));
26714         }
26715         if (flags & NDR_OUT) {
26716                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26717         }
26718         return NDR_ERR_SUCCESS;
26719 }
26720
26721 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26722 {
26723         TALLOC_CTX *_mem_save_handle_0;
26724         if (flags & NDR_IN) {
26725                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26726                         NDR_PULL_ALLOC(ndr, r->in.handle);
26727                 }
26728                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26729                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26730                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26731                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26732                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26733                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26734                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26735                         return 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));
26736                 }
26737                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26738                 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));
26739         }
26740         if (flags & NDR_OUT) {
26741                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26742         }
26743         return NDR_ERR_SUCCESS;
26744 }
26745
26746 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26747 {
26748         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26749         ndr->depth++;
26750         if (flags & NDR_SET_VALUES) {
26751                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26752         }
26753         if (flags & NDR_IN) {
26754                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26755                 ndr->depth++;
26756                 ndr_print_ptr(ndr, "handle", r->in.handle);
26757                 ndr->depth++;
26758                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26759                 ndr->depth--;
26760                 ndr_print_string(ndr, "key_name", r->in.key_name);
26761                 ndr->depth--;
26762         }
26763         if (flags & NDR_OUT) {
26764                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26765                 ndr->depth++;
26766                 ndr_print_WERROR(ndr, "result", r->out.result);
26767                 ndr->depth--;
26768         }
26769         ndr->depth--;
26770 }
26771
26772 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26773 {
26774         if (flags & NDR_IN) {
26775         }
26776         if (flags & NDR_OUT) {
26777                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26778         }
26779         return NDR_ERR_SUCCESS;
26780 }
26781
26782 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26783 {
26784         if (flags & NDR_IN) {
26785         }
26786         if (flags & NDR_OUT) {
26787                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26788         }
26789         return NDR_ERR_SUCCESS;
26790 }
26791
26792 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26793 {
26794         ndr_print_struct(ndr, name, "spoolss_53");
26795         ndr->depth++;
26796         if (flags & NDR_SET_VALUES) {
26797                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26798         }
26799         if (flags & NDR_IN) {
26800                 ndr_print_struct(ndr, "in", "spoolss_53");
26801                 ndr->depth++;
26802                 ndr->depth--;
26803         }
26804         if (flags & NDR_OUT) {
26805                 ndr_print_struct(ndr, "out", "spoolss_53");
26806                 ndr->depth++;
26807                 ndr_print_WERROR(ndr, "result", r->out.result);
26808                 ndr->depth--;
26809         }
26810         ndr->depth--;
26811 }
26812
26813 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26814 {
26815         if (flags & NDR_IN) {
26816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26817                 if (r->in.server) {
26818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26822                 }
26823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26826                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26830                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26831                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26833         }
26834         if (flags & NDR_OUT) {
26835                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26836         }
26837         return NDR_ERR_SUCCESS;
26838 }
26839
26840 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26841 {
26842         uint32_t _ptr_server;
26843         TALLOC_CTX *_mem_save_server_0;
26844         if (flags & NDR_IN) {
26845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26846                 if (_ptr_server) {
26847                         NDR_PULL_ALLOC(ndr, r->in.server);
26848                 } else {
26849                         r->in.server = NULL;
26850                 }
26851                 if (r->in.server) {
26852                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26853                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26854                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26855                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26856                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26857                                 return 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));
26858                         }
26859                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26860                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26861                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26862                 }
26863                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26864                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26865                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26866                         return 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));
26867                 }
26868                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26869                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26870                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26871                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26872                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26873                         return 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));
26874                 }
26875                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26876                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26877                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26879         }
26880         if (flags & NDR_OUT) {
26881                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26882         }
26883         return NDR_ERR_SUCCESS;
26884 }
26885
26886 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26887 {
26888         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26889         ndr->depth++;
26890         if (flags & NDR_SET_VALUES) {
26891                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26892         }
26893         if (flags & NDR_IN) {
26894                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26895                 ndr->depth++;
26896                 ndr_print_ptr(ndr, "server", r->in.server);
26897                 ndr->depth++;
26898                 if (r->in.server) {
26899                         ndr_print_string(ndr, "server", r->in.server);
26900                 }
26901                 ndr->depth--;
26902                 ndr_print_string(ndr, "architecture", r->in.architecture);
26903                 ndr_print_string(ndr, "driver", r->in.driver);
26904                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26905                 ndr_print_uint32(ndr, "version", r->in.version);
26906                 ndr->depth--;
26907         }
26908         if (flags & NDR_OUT) {
26909                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26910                 ndr->depth++;
26911                 ndr_print_WERROR(ndr, "result", r->out.result);
26912                 ndr->depth--;
26913         }
26914         ndr->depth--;
26915 }
26916
26917 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26918 {
26919         if (flags & NDR_IN) {
26920         }
26921         if (flags & NDR_OUT) {
26922                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26923         }
26924         return NDR_ERR_SUCCESS;
26925 }
26926
26927 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26928 {
26929         if (flags & NDR_IN) {
26930         }
26931         if (flags & NDR_OUT) {
26932                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26933         }
26934         return NDR_ERR_SUCCESS;
26935 }
26936
26937 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26938 {
26939         ndr_print_struct(ndr, name, "spoolss_55");
26940         ndr->depth++;
26941         if (flags & NDR_SET_VALUES) {
26942                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26943         }
26944         if (flags & NDR_IN) {
26945                 ndr_print_struct(ndr, "in", "spoolss_55");
26946                 ndr->depth++;
26947                 ndr->depth--;
26948         }
26949         if (flags & NDR_OUT) {
26950                 ndr_print_struct(ndr, "out", "spoolss_55");
26951                 ndr->depth++;
26952                 ndr_print_WERROR(ndr, "result", r->out.result);
26953                 ndr->depth--;
26954         }
26955         ndr->depth--;
26956 }
26957
26958 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26959 {
26960         if (flags & NDR_IN) {
26961         }
26962         if (flags & NDR_OUT) {
26963                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26964         }
26965         return NDR_ERR_SUCCESS;
26966 }
26967
26968 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26969 {
26970         if (flags & NDR_IN) {
26971         }
26972         if (flags & NDR_OUT) {
26973                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26974         }
26975         return NDR_ERR_SUCCESS;
26976 }
26977
26978 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26979 {
26980         ndr_print_struct(ndr, name, "spoolss_56");
26981         ndr->depth++;
26982         if (flags & NDR_SET_VALUES) {
26983                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26984         }
26985         if (flags & NDR_IN) {
26986                 ndr_print_struct(ndr, "in", "spoolss_56");
26987                 ndr->depth++;
26988                 ndr->depth--;
26989         }
26990         if (flags & NDR_OUT) {
26991                 ndr_print_struct(ndr, "out", "spoolss_56");
26992                 ndr->depth++;
26993                 ndr_print_WERROR(ndr, "result", r->out.result);
26994                 ndr->depth--;
26995         }
26996         ndr->depth--;
26997 }
26998
26999 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
27000 {
27001         if (flags & NDR_IN) {
27002         }
27003         if (flags & NDR_OUT) {
27004                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27005         }
27006         return NDR_ERR_SUCCESS;
27007 }
27008
27009 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
27010 {
27011         if (flags & NDR_IN) {
27012         }
27013         if (flags & NDR_OUT) {
27014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27015         }
27016         return NDR_ERR_SUCCESS;
27017 }
27018
27019 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
27020 {
27021         ndr_print_struct(ndr, name, "spoolss_57");
27022         ndr->depth++;
27023         if (flags & NDR_SET_VALUES) {
27024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27025         }
27026         if (flags & NDR_IN) {
27027                 ndr_print_struct(ndr, "in", "spoolss_57");
27028                 ndr->depth++;
27029                 ndr->depth--;
27030         }
27031         if (flags & NDR_OUT) {
27032                 ndr_print_struct(ndr, "out", "spoolss_57");
27033                 ndr->depth++;
27034                 ndr_print_WERROR(ndr, "result", r->out.result);
27035                 ndr->depth--;
27036         }
27037         ndr->depth--;
27038 }
27039
27040 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
27041 {
27042         if (flags & NDR_IN) {
27043                 if (r->in.handle == NULL) {
27044                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27045                 }
27046                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27050                 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));
27051                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
27052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
27053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27054                 if (r->in.status_code == NULL) {
27055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27056                 }
27057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
27058         }
27059         if (flags & NDR_OUT) {
27060                 if (r->out.out_data == NULL) {
27061                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27062                 }
27063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27064                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
27065                 if (r->out.needed == NULL) {
27066                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27067                 }
27068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27069                 if (r->out.status_code == NULL) {
27070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27071                 }
27072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
27073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27074         }
27075         return NDR_ERR_SUCCESS;
27076 }
27077
27078 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
27079 {
27080         TALLOC_CTX *_mem_save_handle_0;
27081         TALLOC_CTX *_mem_save_needed_0;
27082         TALLOC_CTX *_mem_save_status_code_0;
27083         if (flags & NDR_IN) {
27084                 ZERO_STRUCT(r->out);
27085
27086                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27087                         NDR_PULL_ALLOC(ndr, r->in.handle);
27088                 }
27089                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27090                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27091                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27092                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27093                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
27094                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
27095                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
27096                         return 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));
27097                 }
27098                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
27099                 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));
27100                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
27101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
27102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
27103                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27104                         NDR_PULL_ALLOC(ndr, r->in.status_code);
27105                 }
27106                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27107                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
27108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
27109                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27110                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
27111                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
27112                 NDR_PULL_ALLOC(ndr, r->out.needed);
27113                 ZERO_STRUCTP(r->out.needed);
27114                 NDR_PULL_ALLOC(ndr, r->out.status_code);
27115                 *r->out.status_code = *r->in.status_code;
27116         }
27117         if (flags & NDR_OUT) {
27118                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
27119                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27120                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
27121                 }
27122                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
27123                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27124                         NDR_PULL_ALLOC(ndr, r->out.needed);
27125                 }
27126                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27127                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27129                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27131                         NDR_PULL_ALLOC(ndr, r->out.status_code);
27132                 }
27133                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27134                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
27135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
27136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27137                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27138                 if (r->out.out_data) {
27139                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
27140                 }
27141         }
27142         return NDR_ERR_SUCCESS;
27143 }
27144
27145 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
27146 {
27147         ndr_print_struct(ndr, name, "spoolss_XcvData");
27148         ndr->depth++;
27149         if (flags & NDR_SET_VALUES) {
27150                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27151         }
27152         if (flags & NDR_IN) {
27153                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
27154                 ndr->depth++;
27155                 ndr_print_ptr(ndr, "handle", r->in.handle);
27156                 ndr->depth++;
27157                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27158                 ndr->depth--;
27159                 ndr_print_string(ndr, "function_name", r->in.function_name);
27160                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
27161                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
27162                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
27163                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
27164                 ndr->depth++;
27165                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
27166                 ndr->depth--;
27167                 ndr->depth--;
27168         }
27169         if (flags & NDR_OUT) {
27170                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
27171                 ndr->depth++;
27172                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
27173                 ndr->depth++;
27174                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
27175                 ndr->depth--;
27176                 ndr_print_ptr(ndr, "needed", r->out.needed);
27177                 ndr->depth++;
27178                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27179                 ndr->depth--;
27180                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
27181                 ndr->depth++;
27182                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
27183                 ndr->depth--;
27184                 ndr_print_WERROR(ndr, "result", r->out.result);
27185                 ndr->depth--;
27186         }
27187         ndr->depth--;
27188 }
27189
27190 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
27191 {
27192         if (flags & NDR_IN) {
27193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
27194                 if (r->in.servername) {
27195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27196                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27197                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27198                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27199                 }
27200                 if (r->in.info_ctr == NULL) {
27201                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27202                 }
27203                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27204                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
27205         }
27206         if (flags & NDR_OUT) {
27207                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27208         }
27209         return NDR_ERR_SUCCESS;
27210 }
27211
27212 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
27213 {
27214         uint32_t _ptr_servername;
27215         TALLOC_CTX *_mem_save_servername_0;
27216         TALLOC_CTX *_mem_save_info_ctr_0;
27217         if (flags & NDR_IN) {
27218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
27219                 if (_ptr_servername) {
27220                         NDR_PULL_ALLOC(ndr, r->in.servername);
27221                 } else {
27222                         r->in.servername = NULL;
27223                 }
27224                 if (r->in.servername) {
27225                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27226                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
27227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
27228                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
27229                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
27230                                 return 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));
27231                         }
27232                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
27233                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
27234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
27235                 }
27236                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27237                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27238                 }
27239                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27240                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27241                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27242                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27243                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27244         }
27245         if (flags & NDR_OUT) {
27246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27247         }
27248         return NDR_ERR_SUCCESS;
27249 }
27250
27251 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27252 {
27253         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27254         ndr->depth++;
27255         if (flags & NDR_SET_VALUES) {
27256                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27257         }
27258         if (flags & NDR_IN) {
27259                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27260                 ndr->depth++;
27261                 ndr_print_ptr(ndr, "servername", r->in.servername);
27262                 ndr->depth++;
27263                 if (r->in.servername) {
27264                         ndr_print_string(ndr, "servername", r->in.servername);
27265                 }
27266                 ndr->depth--;
27267                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27268                 ndr->depth++;
27269                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27270                 ndr->depth--;
27271                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
27272                 ndr->depth--;
27273         }
27274         if (flags & NDR_OUT) {
27275                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
27276                 ndr->depth++;
27277                 ndr_print_WERROR(ndr, "result", r->out.result);
27278                 ndr->depth--;
27279         }
27280         ndr->depth--;
27281 }
27282
27283 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
27284 {
27285         if (flags & NDR_IN) {
27286         }
27287         if (flags & NDR_OUT) {
27288                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27289         }
27290         return NDR_ERR_SUCCESS;
27291 }
27292
27293 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27294 {
27295         if (flags & NDR_IN) {
27296         }
27297         if (flags & NDR_OUT) {
27298                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27299         }
27300         return NDR_ERR_SUCCESS;
27301 }
27302
27303 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27304 {
27305         ndr_print_struct(ndr, name, "spoolss_5a");
27306         ndr->depth++;
27307         if (flags & NDR_SET_VALUES) {
27308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27309         }
27310         if (flags & NDR_IN) {
27311                 ndr_print_struct(ndr, "in", "spoolss_5a");
27312                 ndr->depth++;
27313                 ndr->depth--;
27314         }
27315         if (flags & NDR_OUT) {
27316                 ndr_print_struct(ndr, "out", "spoolss_5a");
27317                 ndr->depth++;
27318                 ndr_print_WERROR(ndr, "result", r->out.result);
27319                 ndr->depth--;
27320         }
27321         ndr->depth--;
27322 }
27323
27324 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27325 {
27326         if (flags & NDR_IN) {
27327         }
27328         if (flags & NDR_OUT) {
27329                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27330         }
27331         return NDR_ERR_SUCCESS;
27332 }
27333
27334 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27335 {
27336         if (flags & NDR_IN) {
27337         }
27338         if (flags & NDR_OUT) {
27339                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27340         }
27341         return NDR_ERR_SUCCESS;
27342 }
27343
27344 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27345 {
27346         ndr_print_struct(ndr, name, "spoolss_5b");
27347         ndr->depth++;
27348         if (flags & NDR_SET_VALUES) {
27349                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27350         }
27351         if (flags & NDR_IN) {
27352                 ndr_print_struct(ndr, "in", "spoolss_5b");
27353                 ndr->depth++;
27354                 ndr->depth--;
27355         }
27356         if (flags & NDR_OUT) {
27357                 ndr_print_struct(ndr, "out", "spoolss_5b");
27358                 ndr->depth++;
27359                 ndr_print_WERROR(ndr, "result", r->out.result);
27360                 ndr->depth--;
27361         }
27362         ndr->depth--;
27363 }
27364
27365 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27366 {
27367         if (flags & NDR_IN) {
27368         }
27369         if (flags & NDR_OUT) {
27370                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27371         }
27372         return NDR_ERR_SUCCESS;
27373 }
27374
27375 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27376 {
27377         if (flags & NDR_IN) {
27378         }
27379         if (flags & NDR_OUT) {
27380                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27381         }
27382         return NDR_ERR_SUCCESS;
27383 }
27384
27385 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27386 {
27387         ndr_print_struct(ndr, name, "spoolss_5c");
27388         ndr->depth++;
27389         if (flags & NDR_SET_VALUES) {
27390                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27391         }
27392         if (flags & NDR_IN) {
27393                 ndr_print_struct(ndr, "in", "spoolss_5c");
27394                 ndr->depth++;
27395                 ndr->depth--;
27396         }
27397         if (flags & NDR_OUT) {
27398                 ndr_print_struct(ndr, "out", "spoolss_5c");
27399                 ndr->depth++;
27400                 ndr_print_WERROR(ndr, "result", r->out.result);
27401                 ndr->depth--;
27402         }
27403         ndr->depth--;
27404 }
27405
27406 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27407 {
27408         if (flags & NDR_IN) {
27409         }
27410         if (flags & NDR_OUT) {
27411                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27412         }
27413         return NDR_ERR_SUCCESS;
27414 }
27415
27416 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27417 {
27418         if (flags & NDR_IN) {
27419         }
27420         if (flags & NDR_OUT) {
27421                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27422         }
27423         return NDR_ERR_SUCCESS;
27424 }
27425
27426 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27427 {
27428         ndr_print_struct(ndr, name, "spoolss_5d");
27429         ndr->depth++;
27430         if (flags & NDR_SET_VALUES) {
27431                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27432         }
27433         if (flags & NDR_IN) {
27434                 ndr_print_struct(ndr, "in", "spoolss_5d");
27435                 ndr->depth++;
27436                 ndr->depth--;
27437         }
27438         if (flags & NDR_OUT) {
27439                 ndr_print_struct(ndr, "out", "spoolss_5d");
27440                 ndr->depth++;
27441                 ndr_print_WERROR(ndr, "result", r->out.result);
27442                 ndr->depth--;
27443         }
27444         ndr->depth--;
27445 }
27446
27447 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27448 {
27449         if (flags & NDR_IN) {
27450         }
27451         if (flags & NDR_OUT) {
27452                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27453         }
27454         return NDR_ERR_SUCCESS;
27455 }
27456
27457 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27458 {
27459         if (flags & NDR_IN) {
27460         }
27461         if (flags & NDR_OUT) {
27462                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27463         }
27464         return NDR_ERR_SUCCESS;
27465 }
27466
27467 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27468 {
27469         ndr_print_struct(ndr, name, "spoolss_5e");
27470         ndr->depth++;
27471         if (flags & NDR_SET_VALUES) {
27472                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27473         }
27474         if (flags & NDR_IN) {
27475                 ndr_print_struct(ndr, "in", "spoolss_5e");
27476                 ndr->depth++;
27477                 ndr->depth--;
27478         }
27479         if (flags & NDR_OUT) {
27480                 ndr_print_struct(ndr, "out", "spoolss_5e");
27481                 ndr->depth++;
27482                 ndr_print_WERROR(ndr, "result", r->out.result);
27483                 ndr->depth--;
27484         }
27485         ndr->depth--;
27486 }
27487
27488 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27489 {
27490         if (flags & NDR_IN) {
27491         }
27492         if (flags & NDR_OUT) {
27493                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27494         }
27495         return NDR_ERR_SUCCESS;
27496 }
27497
27498 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27499 {
27500         if (flags & NDR_IN) {
27501         }
27502         if (flags & NDR_OUT) {
27503                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27504         }
27505         return NDR_ERR_SUCCESS;
27506 }
27507
27508 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27509 {
27510         ndr_print_struct(ndr, name, "spoolss_5f");
27511         ndr->depth++;
27512         if (flags & NDR_SET_VALUES) {
27513                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27514         }
27515         if (flags & NDR_IN) {
27516                 ndr_print_struct(ndr, "in", "spoolss_5f");
27517                 ndr->depth++;
27518                 ndr->depth--;
27519         }
27520         if (flags & NDR_OUT) {
27521                 ndr_print_struct(ndr, "out", "spoolss_5f");
27522                 ndr->depth++;
27523                 ndr_print_WERROR(ndr, "result", r->out.result);
27524                 ndr->depth--;
27525         }
27526         ndr->depth--;
27527 }
27528
27529 static const struct ndr_interface_call spoolss_calls[] = {
27530         {
27531                 "spoolss_EnumPrinters",
27532                 sizeof(struct spoolss_EnumPrinters),
27533                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27534                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27535                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27536                 false,
27537         },
27538         {
27539                 "spoolss_OpenPrinter",
27540                 sizeof(struct spoolss_OpenPrinter),
27541                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27542                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27543                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27544                 false,
27545         },
27546         {
27547                 "spoolss_SetJob",
27548                 sizeof(struct spoolss_SetJob),
27549                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27550                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27551                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27552                 false,
27553         },
27554         {
27555                 "spoolss_GetJob",
27556                 sizeof(struct spoolss_GetJob),
27557                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27558                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27559                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27560                 false,
27561         },
27562         {
27563                 "spoolss_EnumJobs",
27564                 sizeof(struct spoolss_EnumJobs),
27565                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27566                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27567                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27568                 false,
27569         },
27570         {
27571                 "spoolss_AddPrinter",
27572                 sizeof(struct spoolss_AddPrinter),
27573                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27574                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27575                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27576                 false,
27577         },
27578         {
27579                 "spoolss_DeletePrinter",
27580                 sizeof(struct spoolss_DeletePrinter),
27581                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27582                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27583                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27584                 false,
27585         },
27586         {
27587                 "spoolss_SetPrinter",
27588                 sizeof(struct spoolss_SetPrinter),
27589                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27590                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27591                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27592                 false,
27593         },
27594         {
27595                 "spoolss_GetPrinter",
27596                 sizeof(struct spoolss_GetPrinter),
27597                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27598                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27599                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27600                 false,
27601         },
27602         {
27603                 "spoolss_AddPrinterDriver",
27604                 sizeof(struct spoolss_AddPrinterDriver),
27605                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27606                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27607                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27608                 false,
27609         },
27610         {
27611                 "spoolss_EnumPrinterDrivers",
27612                 sizeof(struct spoolss_EnumPrinterDrivers),
27613                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27614                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27615                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27616                 false,
27617         },
27618         {
27619                 "spoolss_GetPrinterDriver",
27620                 sizeof(struct spoolss_GetPrinterDriver),
27621                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27622                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27623                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27624                 false,
27625         },
27626         {
27627                 "spoolss_GetPrinterDriverDirectory",
27628                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27629                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27630                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27631                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27632                 false,
27633         },
27634         {
27635                 "spoolss_DeletePrinterDriver",
27636                 sizeof(struct spoolss_DeletePrinterDriver),
27637                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27638                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27639                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27640                 false,
27641         },
27642         {
27643                 "spoolss_AddPrintProcessor",
27644                 sizeof(struct spoolss_AddPrintProcessor),
27645                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27646                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27647                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27648                 false,
27649         },
27650         {
27651                 "spoolss_EnumPrintProcessors",
27652                 sizeof(struct spoolss_EnumPrintProcessors),
27653                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27654                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27655                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27656                 false,
27657         },
27658         {
27659                 "spoolss_GetPrintProcessorDirectory",
27660                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27661                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27662                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27663                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27664                 false,
27665         },
27666         {
27667                 "spoolss_StartDocPrinter",
27668                 sizeof(struct spoolss_StartDocPrinter),
27669                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27670                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27671                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27672                 false,
27673         },
27674         {
27675                 "spoolss_StartPagePrinter",
27676                 sizeof(struct spoolss_StartPagePrinter),
27677                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27678                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27679                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27680                 false,
27681         },
27682         {
27683                 "spoolss_WritePrinter",
27684                 sizeof(struct spoolss_WritePrinter),
27685                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27686                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27687                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27688                 false,
27689         },
27690         {
27691                 "spoolss_EndPagePrinter",
27692                 sizeof(struct spoolss_EndPagePrinter),
27693                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27694                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27695                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27696                 false,
27697         },
27698         {
27699                 "spoolss_AbortPrinter",
27700                 sizeof(struct spoolss_AbortPrinter),
27701                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27702                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27703                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27704                 false,
27705         },
27706         {
27707                 "spoolss_ReadPrinter",
27708                 sizeof(struct spoolss_ReadPrinter),
27709                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27710                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27711                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27712                 false,
27713         },
27714         {
27715                 "spoolss_EndDocPrinter",
27716                 sizeof(struct spoolss_EndDocPrinter),
27717                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27718                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27719                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27720                 false,
27721         },
27722         {
27723                 "spoolss_AddJob",
27724                 sizeof(struct spoolss_AddJob),
27725                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27726                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27727                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27728                 false,
27729         },
27730         {
27731                 "spoolss_ScheduleJob",
27732                 sizeof(struct spoolss_ScheduleJob),
27733                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27734                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27735                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27736                 false,
27737         },
27738         {
27739                 "spoolss_GetPrinterData",
27740                 sizeof(struct spoolss_GetPrinterData),
27741                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27742                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27743                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27744                 false,
27745         },
27746         {
27747                 "spoolss_SetPrinterData",
27748                 sizeof(struct spoolss_SetPrinterData),
27749                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27750                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27751                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27752                 false,
27753         },
27754         {
27755                 "spoolss_WaitForPrinterChange",
27756                 sizeof(struct spoolss_WaitForPrinterChange),
27757                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27758                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27759                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27760                 false,
27761         },
27762         {
27763                 "spoolss_ClosePrinter",
27764                 sizeof(struct spoolss_ClosePrinter),
27765                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27766                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27767                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27768                 false,
27769         },
27770         {
27771                 "spoolss_AddForm",
27772                 sizeof(struct spoolss_AddForm),
27773                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27774                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27775                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27776                 false,
27777         },
27778         {
27779                 "spoolss_DeleteForm",
27780                 sizeof(struct spoolss_DeleteForm),
27781                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27782                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27783                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27784                 false,
27785         },
27786         {
27787                 "spoolss_GetForm",
27788                 sizeof(struct spoolss_GetForm),
27789                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27790                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27791                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27792                 false,
27793         },
27794         {
27795                 "spoolss_SetForm",
27796                 sizeof(struct spoolss_SetForm),
27797                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27798                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27799                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27800                 false,
27801         },
27802         {
27803                 "spoolss_EnumForms",
27804                 sizeof(struct spoolss_EnumForms),
27805                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27806                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27807                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27808                 false,
27809         },
27810         {
27811                 "spoolss_EnumPorts",
27812                 sizeof(struct spoolss_EnumPorts),
27813                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27814                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27815                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27816                 false,
27817         },
27818         {
27819                 "spoolss_EnumMonitors",
27820                 sizeof(struct spoolss_EnumMonitors),
27821                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27822                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27823                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27824                 false,
27825         },
27826         {
27827                 "spoolss_AddPort",
27828                 sizeof(struct spoolss_AddPort),
27829                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27830                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27831                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27832                 false,
27833         },
27834         {
27835                 "spoolss_ConfigurePort",
27836                 sizeof(struct spoolss_ConfigurePort),
27837                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27838                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27839                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27840                 false,
27841         },
27842         {
27843                 "spoolss_DeletePort",
27844                 sizeof(struct spoolss_DeletePort),
27845                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27846                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27847                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27848                 false,
27849         },
27850         {
27851                 "spoolss_CreatePrinterIC",
27852                 sizeof(struct spoolss_CreatePrinterIC),
27853                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27854                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27855                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27856                 false,
27857         },
27858         {
27859                 "spoolss_PlayGDIScriptOnPrinterIC",
27860                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27861                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27862                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27863                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27864                 false,
27865         },
27866         {
27867                 "spoolss_DeletePrinterIC",
27868                 sizeof(struct spoolss_DeletePrinterIC),
27869                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27870                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27871                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27872                 false,
27873         },
27874         {
27875                 "spoolss_AddPrinterConnection",
27876                 sizeof(struct spoolss_AddPrinterConnection),
27877                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27878                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27879                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27880                 false,
27881         },
27882         {
27883                 "spoolss_DeletePrinterConnection",
27884                 sizeof(struct spoolss_DeletePrinterConnection),
27885                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27886                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27887                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27888                 false,
27889         },
27890         {
27891                 "spoolss_PrinterMessageBox",
27892                 sizeof(struct spoolss_PrinterMessageBox),
27893                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27894                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27895                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27896                 false,
27897         },
27898         {
27899                 "spoolss_AddMonitor",
27900                 sizeof(struct spoolss_AddMonitor),
27901                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27902                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27903                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27904                 false,
27905         },
27906         {
27907                 "spoolss_DeleteMonitor",
27908                 sizeof(struct spoolss_DeleteMonitor),
27909                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27910                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27911                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27912                 false,
27913         },
27914         {
27915                 "spoolss_DeletePrintProcessor",
27916                 sizeof(struct spoolss_DeletePrintProcessor),
27917                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27918                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27919                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27920                 false,
27921         },
27922         {
27923                 "spoolss_AddPrintProvidor",
27924                 sizeof(struct spoolss_AddPrintProvidor),
27925                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27926                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27927                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27928                 false,
27929         },
27930         {
27931                 "spoolss_DeletePrintProvidor",
27932                 sizeof(struct spoolss_DeletePrintProvidor),
27933                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27934                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27935                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27936                 false,
27937         },
27938         {
27939                 "spoolss_EnumPrintProcDataTypes",
27940                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27941                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27942                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27943                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27944                 false,
27945         },
27946         {
27947                 "spoolss_ResetPrinter",
27948                 sizeof(struct spoolss_ResetPrinter),
27949                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27950                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27951                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27952                 false,
27953         },
27954         {
27955                 "spoolss_GetPrinterDriver2",
27956                 sizeof(struct spoolss_GetPrinterDriver2),
27957                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27958                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27959                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27960                 false,
27961         },
27962         {
27963                 "spoolss_FindFirstPrinterChangeNotification",
27964                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27965                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27966                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27967                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27968                 false,
27969         },
27970         {
27971                 "spoolss_FindNextPrinterChangeNotification",
27972                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27973                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27974                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27975                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27976                 false,
27977         },
27978         {
27979                 "spoolss_FindClosePrinterNotify",
27980                 sizeof(struct spoolss_FindClosePrinterNotify),
27981                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27982                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27983                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27984                 false,
27985         },
27986         {
27987                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27988                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27989                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27990                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27991                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27992                 false,
27993         },
27994         {
27995                 "spoolss_ReplyOpenPrinter",
27996                 sizeof(struct spoolss_ReplyOpenPrinter),
27997                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27998                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27999                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
28000                 false,
28001         },
28002         {
28003                 "spoolss_RouterReplyPrinter",
28004                 sizeof(struct spoolss_RouterReplyPrinter),
28005                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
28006                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
28007                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
28008                 false,
28009         },
28010         {
28011                 "spoolss_ReplyClosePrinter",
28012                 sizeof(struct spoolss_ReplyClosePrinter),
28013                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
28014                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
28015                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
28016                 false,
28017         },
28018         {
28019                 "spoolss_AddPortEx",
28020                 sizeof(struct spoolss_AddPortEx),
28021                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
28022                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
28023                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
28024                 false,
28025         },
28026         {
28027                 "spoolss_RouterFindFirstPrinterChangeNotification",
28028                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
28029                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
28030                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
28031                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
28032                 false,
28033         },
28034         {
28035                 "spoolss_SpoolerInit",
28036                 sizeof(struct spoolss_SpoolerInit),
28037                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
28038                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
28039                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
28040                 false,
28041         },
28042         {
28043                 "spoolss_ResetPrinterEx",
28044                 sizeof(struct spoolss_ResetPrinterEx),
28045                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
28046                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
28047                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
28048                 false,
28049         },
28050         {
28051                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
28052                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
28053                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28054                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28055                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28056                 false,
28057         },
28058         {
28059                 "spoolss_RouterReplyPrinterEx",
28060                 sizeof(struct spoolss_RouterReplyPrinterEx),
28061                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
28062                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
28063                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
28064                 false,
28065         },
28066         {
28067                 "spoolss_RouterRefreshPrinterChangeNotify",
28068                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
28069                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
28070                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
28071                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
28072                 false,
28073         },
28074         {
28075                 "spoolss_44",
28076                 sizeof(struct spoolss_44),
28077                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
28078                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
28079                 (ndr_print_function_t) ndr_print_spoolss_44,
28080                 false,
28081         },
28082         {
28083                 "spoolss_OpenPrinterEx",
28084                 sizeof(struct spoolss_OpenPrinterEx),
28085                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
28086                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
28087                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
28088                 false,
28089         },
28090         {
28091                 "spoolss_AddPrinterEx",
28092                 sizeof(struct spoolss_AddPrinterEx),
28093                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
28094                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
28095                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
28096                 false,
28097         },
28098         {
28099                 "spoolss_47",
28100                 sizeof(struct spoolss_47),
28101                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
28102                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
28103                 (ndr_print_function_t) ndr_print_spoolss_47,
28104                 false,
28105         },
28106         {
28107                 "spoolss_EnumPrinterData",
28108                 sizeof(struct spoolss_EnumPrinterData),
28109                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
28110                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
28111                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
28112                 false,
28113         },
28114         {
28115                 "spoolss_DeletePrinterData",
28116                 sizeof(struct spoolss_DeletePrinterData),
28117                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
28118                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
28119                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
28120                 false,
28121         },
28122         {
28123                 "spoolss_4a",
28124                 sizeof(struct spoolss_4a),
28125                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
28126                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
28127                 (ndr_print_function_t) ndr_print_spoolss_4a,
28128                 false,
28129         },
28130         {
28131                 "spoolss_4b",
28132                 sizeof(struct spoolss_4b),
28133                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
28134                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
28135                 (ndr_print_function_t) ndr_print_spoolss_4b,
28136                 false,
28137         },
28138         {
28139                 "spoolss_4c",
28140                 sizeof(struct spoolss_4c),
28141                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
28142                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
28143                 (ndr_print_function_t) ndr_print_spoolss_4c,
28144                 false,
28145         },
28146         {
28147                 "spoolss_SetPrinterDataEx",
28148                 sizeof(struct spoolss_SetPrinterDataEx),
28149                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
28150                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
28151                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
28152                 false,
28153         },
28154         {
28155                 "spoolss_GetPrinterDataEx",
28156                 sizeof(struct spoolss_GetPrinterDataEx),
28157                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
28158                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
28159                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
28160                 false,
28161         },
28162         {
28163                 "spoolss_EnumPrinterDataEx",
28164                 sizeof(struct spoolss_EnumPrinterDataEx),
28165                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
28166                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
28167                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
28168                 false,
28169         },
28170         {
28171                 "spoolss_EnumPrinterKey",
28172                 sizeof(struct spoolss_EnumPrinterKey),
28173                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
28174                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
28175                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
28176                 false,
28177         },
28178         {
28179                 "spoolss_DeletePrinterDataEx",
28180                 sizeof(struct spoolss_DeletePrinterDataEx),
28181                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
28182                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
28183                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
28184                 false,
28185         },
28186         {
28187                 "spoolss_DeletePrinterKey",
28188                 sizeof(struct spoolss_DeletePrinterKey),
28189                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
28190                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
28191                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
28192                 false,
28193         },
28194         {
28195                 "spoolss_53",
28196                 sizeof(struct spoolss_53),
28197                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
28198                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
28199                 (ndr_print_function_t) ndr_print_spoolss_53,
28200                 false,
28201         },
28202         {
28203                 "spoolss_DeletePrinterDriverEx",
28204                 sizeof(struct spoolss_DeletePrinterDriverEx),
28205                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
28206                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
28207                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
28208                 false,
28209         },
28210         {
28211                 "spoolss_55",
28212                 sizeof(struct spoolss_55),
28213                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
28214                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
28215                 (ndr_print_function_t) ndr_print_spoolss_55,
28216                 false,
28217         },
28218         {
28219                 "spoolss_56",
28220                 sizeof(struct spoolss_56),
28221                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
28222                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
28223                 (ndr_print_function_t) ndr_print_spoolss_56,
28224                 false,
28225         },
28226         {
28227                 "spoolss_57",
28228                 sizeof(struct spoolss_57),
28229                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
28230                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
28231                 (ndr_print_function_t) ndr_print_spoolss_57,
28232                 false,
28233         },
28234         {
28235                 "spoolss_XcvData",
28236                 sizeof(struct spoolss_XcvData),
28237                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
28238                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
28239                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
28240                 false,
28241         },
28242         {
28243                 "spoolss_AddPrinterDriverEx",
28244                 sizeof(struct spoolss_AddPrinterDriverEx),
28245                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28246                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28247                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28248                 false,
28249         },
28250         {
28251                 "spoolss_5a",
28252                 sizeof(struct spoolss_5a),
28253                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28254                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28255                 (ndr_print_function_t) ndr_print_spoolss_5a,
28256                 false,
28257         },
28258         {
28259                 "spoolss_5b",
28260                 sizeof(struct spoolss_5b),
28261                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28262                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28263                 (ndr_print_function_t) ndr_print_spoolss_5b,
28264                 false,
28265         },
28266         {
28267                 "spoolss_5c",
28268                 sizeof(struct spoolss_5c),
28269                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
28270                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
28271                 (ndr_print_function_t) ndr_print_spoolss_5c,
28272                 false,
28273         },
28274         {
28275                 "spoolss_5d",
28276                 sizeof(struct spoolss_5d),
28277                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
28278                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
28279                 (ndr_print_function_t) ndr_print_spoolss_5d,
28280                 false,
28281         },
28282         {
28283                 "spoolss_5e",
28284                 sizeof(struct spoolss_5e),
28285                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
28286                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28287                 (ndr_print_function_t) ndr_print_spoolss_5e,
28288                 false,
28289         },
28290         {
28291                 "spoolss_5f",
28292                 sizeof(struct spoolss_5f),
28293                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28294                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28295                 (ndr_print_function_t) ndr_print_spoolss_5f,
28296                 false,
28297         },
28298         { NULL, 0, NULL, NULL, NULL, false }
28299 };
28300
28301 static const char * const spoolss_endpoint_strings[] = {
28302         "ncacn_np:[\\pipe\\spoolss]",
28303 };
28304
28305 static const struct ndr_interface_string_array spoolss_endpoints = {
28306         .count  = 1,
28307         .names  = spoolss_endpoint_strings
28308 };
28309
28310 static const char * const spoolss_authservice_strings[] = {
28311         "host",
28312 };
28313
28314 static const struct ndr_interface_string_array spoolss_authservices = {
28315         .count  = 1,
28316         .names  = spoolss_authservice_strings
28317 };
28318
28319
28320 const struct ndr_interface_table ndr_table_spoolss = {
28321         .name           = "spoolss",
28322         .syntax_id      = {
28323                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28324                 NDR_SPOOLSS_VERSION
28325         },
28326         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28327         .num_calls      = 96,
28328         .calls          = spoolss_calls,
28329         .endpoints      = &spoolss_endpoints,
28330         .authservices   = &spoolss_authservices
28331 };
28332