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                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  22         }
  23         if (ndr_flags & NDR_BUFFERS) {
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  29 {
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 2));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  39                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  40                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43         }
  44         return NDR_ERR_SUCCESS;
  45 }
  46
  47 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  48 {
  49         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  50 }
  51
  52 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  53 {
  54         if (ndr_flags & NDR_SCALARS) {
  55                 NDR_CHECK(ndr_push_align(ndr, 5));
  56                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  57                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  58                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  59         }
  60         if (ndr_flags & NDR_BUFFERS) {
  61                 if (r->time) {
  62                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  63                 }
  64         }
  65         return NDR_ERR_SUCCESS;
  66 }
  67
  68 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  69 {
  70         uint32_t _ptr_time;
  71         TALLOC_CTX *_mem_save_time_0;
  72         if (ndr_flags & NDR_SCALARS) {
  73                 NDR_CHECK(ndr_pull_align(ndr, 5));
  74                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  75                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  76                 if (_ptr_time) {
  77                         NDR_PULL_ALLOC(ndr, r->time);
  78                 } else {
  79                         r->time = NULL;
  80                 }
  81                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  82         }
  83         if (ndr_flags & NDR_BUFFERS) {
  84                 if (r->time) {
  85                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  86                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  87                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  88                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
  89                 }
  90         }
  91         return NDR_ERR_SUCCESS;
  92 }
  93
  94 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
  95 {
  96         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
  97         ndr->depth++;
  98         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
  99         ndr_print_ptr(ndr, "time", r->time);
 100         ndr->depth++;
 101         if (r->time) {
 102                 ndr_print_spoolss_Time(ndr, "time", r->time);
 103         }
 104         ndr->depth--;
 105         ndr->depth--;
 106 }
 107
 108 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 109 {
 110         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 111         return NDR_ERR_SUCCESS;
 112 }
 113
 114 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 115 {
 116         uint16_t v;
 117         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 118         *r = v;
 119         return NDR_ERR_SUCCESS;
 120 }
 121
 122 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 123 {
 124         const char *val = NULL;
 125
 126         switch (r) {
 127                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 128                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 129                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 130         }
 131         ndr_print_enum(ndr, name, "ENUM", val, r);
 132 }
 133
 134 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 135 {
 136         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 137         return NDR_ERR_SUCCESS;
 138 }
 139
 140 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 141 {
 142         uint32_t v;
 143         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 144         *r = v;
 145         return NDR_ERR_SUCCESS;
 146 }
 147
 148 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 149 {
 150         const char *val = NULL;
 151
 152         switch (r) {
 153                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 154                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 155                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 156                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 157                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 158         }
 159         ndr_print_enum(ndr, name, "ENUM", val, r);
 160 }
 161
 162 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 163 {
 164         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 165         return NDR_ERR_SUCCESS;
 166 }
 167
 168 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 169 {
 170         uint32_t v;
 171         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 172         *r = v;
 173         return NDR_ERR_SUCCESS;
 174 }
 175
 176 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 177 {
 178         const char *val = NULL;
 179
 180         switch (r) {
 181                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 182                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 183                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 184         }
 185         ndr_print_enum(ndr, name, "ENUM", val, r);
 186 }
 187
 188 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 189 {
 190         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 191         return NDR_ERR_SUCCESS;
 192 }
 193
 194 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 195 {
 196         uint32_t v;
 197         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 198         *r = v;
 199         return NDR_ERR_SUCCESS;
 200 }
 201
 202 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 203 {
 204         const char *val = NULL;
 205
 206         switch (r) {
 207                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 208                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 209                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 210                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 211                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 212         }
 213         ndr_print_enum(ndr, name, "ENUM", val, r);
 214 }
 215
 216 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 217 {
 218         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 219         return NDR_ERR_SUCCESS;
 220 }
 221
 222 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 223 {
 224         uint32_t v;
 225         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 226         *r = v;
 227         return NDR_ERR_SUCCESS;
 228 }
 229
 230 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 231 {
 232         ndr_print_uint32(ndr, name, r);
 233         ndr->depth++;
 234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 259         ndr->depth--;
 260 }
 261
 262 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 263 {
 264         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 265         return NDR_ERR_SUCCESS;
 266 }
 267
 268 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 269 {
 270         uint32_t v;
 271         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 272         *r = v;
 273         return NDR_ERR_SUCCESS;
 274 }
 275
 276 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 277 {
 278         ndr_print_uint32(ndr, name, r);
 279         ndr->depth++;
 280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 283         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 284         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 285         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 286         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 287         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 288         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 289         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 290         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 293         ndr->depth--;
 294 }
 295
 296 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 297 {
 298         if (ndr_flags & NDR_SCALARS) {
 299                 NDR_CHECK(ndr_push_align(ndr, 5));
 300                 {
 301                         uint32_t _flags_save_string = ndr->flags;
 302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 303                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 304                         ndr->flags = _flags_save_string;
 305                 }
 306                 {
 307                         uint32_t _flags_save_string = ndr->flags;
 308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 309                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 310                         ndr->flags = _flags_save_string;
 311                 }
 312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 315                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 325                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 327                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 330                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 331                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 334                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 335                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 339                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 340         }
 341         if (ndr_flags & NDR_BUFFERS) {
 342                 {
 343                         uint32_t _flags_save_string = ndr->flags;
 344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 345                         if (r->printername) {
 346                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
 347                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 348                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
 349                         }
 350                         ndr->flags = _flags_save_string;
 351                 }
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 355                         if (r->servername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 358                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
 359                         }
 360                         ndr->flags = _flags_save_string;
 361                 }
 362         }
 363         return NDR_ERR_SUCCESS;
 364 }
 365
 366 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 367 {
 368         uint32_t _ptr_printername;
 369         TALLOC_CTX *_mem_save_printername_0;
 370         uint32_t _ptr_servername;
 371         TALLOC_CTX *_mem_save_servername_0;
 372         if (ndr_flags & NDR_SCALARS) {
 373                 NDR_CHECK(ndr_pull_align(ndr, 5));
 374                 {
 375                         uint32_t _flags_save_string = ndr->flags;
 376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 377                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 378                         if (_ptr_printername) {
 379                                 NDR_PULL_ALLOC(ndr, r->printername);
 380                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 381                         } else {
 382                                 r->printername = NULL;
 383                         }
 384                         ndr->flags = _flags_save_string;
 385                 }
 386                 {
 387                         uint32_t _flags_save_string = ndr->flags;
 388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 389                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 390                         if (_ptr_servername) {
 391                                 NDR_PULL_ALLOC(ndr, r->servername);
 392                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 393                         } else {
 394                                 r->servername = NULL;
 395                         }
 396                         ndr->flags = _flags_save_string;
 397                 }
 398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 401                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 411                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 413                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 416                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 417                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 420                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 421                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 425                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 426         }
 427         if (ndr_flags & NDR_BUFFERS) {
 428                 {
 429                         uint32_t _flags_save_string = ndr->flags;
 430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 431                         if (r->printername) {
 432                                 uint32_t _relative_save_offset;
 433                                 _relative_save_offset = ndr->offset;
 434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 435                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 436                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 439                                 ndr->offset = _relative_save_offset;
 440                         }
 441                         ndr->flags = _flags_save_string;
 442                 }
 443                 {
 444                         uint32_t _flags_save_string = ndr->flags;
 445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 446                         if (r->servername) {
 447                                 uint32_t _relative_save_offset;
 448                                 _relative_save_offset = ndr->offset;
 449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 450                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 451                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 454                                 ndr->offset = _relative_save_offset;
 455                         }
 456                         ndr->flags = _flags_save_string;
 457                 }
 458         }
 459         return NDR_ERR_SUCCESS;
 460 }
 461
 462 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 463 {
 464         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 465         ndr->depth++;
 466         ndr_print_ptr(ndr, "printername", r->printername);
 467         ndr->depth++;
 468         if (r->printername) {
 469                 ndr_print_string(ndr, "printername", r->printername);
 470         }
 471         ndr->depth--;
 472         ndr_print_ptr(ndr, "servername", r->servername);
 473         ndr->depth++;
 474         if (r->servername) {
 475                 ndr_print_string(ndr, "servername", r->servername);
 476         }
 477         ndr->depth--;
 478         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 479         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 480         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 481         ndr_print_spoolss_Time(ndr, "time", &r->time);
 482         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 483         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 484         ndr_print_uint32(ndr, "version", r->version);
 485         ndr_print_uint32(ndr, "free_build", r->free_build);
 486         ndr_print_uint32(ndr, "spooling", r->spooling);
 487         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 488         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 489         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 490         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 491         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 492         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 493         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 494         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 495         ndr_print_uint32(ndr, "change_id", r->change_id);
 496         ndr_print_WERROR(ndr, "last_error", r->last_error);
 497         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 498         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 499         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 500         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 501         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 502         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 503         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 504         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 505         ndr->depth--;
 506 }
 507
 508 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 509 {
 510         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 511 }
 512
 513 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 514 {
 515         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 516         return NDR_ERR_SUCCESS;
 517 }
 518
 519 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 520 {
 521         uint32_t v;
 522         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 523         *r = v;
 524         return NDR_ERR_SUCCESS;
 525 }
 526
 527 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 528 {
 529         ndr_print_uint32(ndr, name, r);
 530         ndr->depth++;
 531         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 532         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 559         ndr->depth--;
 560 }
 561
 562 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 563 {
 564         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 565         return NDR_ERR_SUCCESS;
 566 }
 567
 568 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 569 {
 570         uint16_t v;
 571         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 572         *r = v;
 573         return NDR_ERR_SUCCESS;
 574 }
 575
 576 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 577 {
 578         const char *val = NULL;
 579
 580         switch (r) {
 581                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 582                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 583                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 584         }
 585         ndr_print_enum(ndr, name, "ENUM", val, r);
 586 }
 587
 588 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 589 {
 590         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 595 {
 596         uint16_t v;
 597         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 598         *r = v;
 599         return NDR_ERR_SUCCESS;
 600 }
 601
 602 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 603 {
 604         const char *val = NULL;
 605
 606         switch (r) {
 607                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 608                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 609         }
 610         ndr_print_enum(ndr, name, "ENUM", val, r);
 611 }
 612
 613 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 614 {
 615         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 616         return NDR_ERR_SUCCESS;
 617 }
 618
 619 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 620 {
 621         uint16_t v;
 622         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 623         *r = v;
 624         return NDR_ERR_SUCCESS;
 625 }
 626
 627 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 628 {
 629         const char *val = NULL;
 630
 631         switch (r) {
 632                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 633                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 634                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 635                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 636                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 637                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 638                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 639                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 640                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 641                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 642                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 643                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 644                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 645                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 646                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 647                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 648                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 649                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 650                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 651                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 652                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 653                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 654                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 655                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 656                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 657                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 658                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 659                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 660                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 661                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 662                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 663                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 664                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 665                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 666                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 667                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 668                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 669                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 670                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 671                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 672                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 673                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 674                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 675                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 676                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 677                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 678                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 679                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 680                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 681                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 682                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 683                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 684                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 685                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 686                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 687                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 688                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 689                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 690                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 691                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 692                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 693                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 694                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 695                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 696                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 697                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 698                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 699                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 700                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 701                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 702                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 703                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 704                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 705                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 706                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 707                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 708                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 709                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 710                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 711                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 712                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 713                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 714                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 715                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 716                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 717                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 718                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 719                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 720                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 721                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 722                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 723         }
 724         ndr_print_enum(ndr, name, "ENUM", val, r);
 725 }
 726
 727 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 728 {
 729         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 730         return NDR_ERR_SUCCESS;
 731 }
 732
 733 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 734 {
 735         uint16_t v;
 736         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 737         *r = v;
 738         return NDR_ERR_SUCCESS;
 739 }
 740
 741 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 742 {
 743         const char *val = NULL;
 744
 745         switch (r) {
 746                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 747                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 748                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 749                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 750                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 751                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 752                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 753                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 754                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 755                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 756                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 757                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 758                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 759         }
 760         ndr_print_enum(ndr, name, "ENUM", val, r);
 761 }
 762
 763 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 764 {
 765         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 766         return NDR_ERR_SUCCESS;
 767 }
 768
 769 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 770 {
 771         uint16_t v;
 772         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 773         *r = v;
 774         return NDR_ERR_SUCCESS;
 775 }
 776
 777 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 778 {
 779         const char *val = NULL;
 780
 781         switch (r) {
 782                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 783                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 784                 case DMRES_LOW: val = "DMRES_LOW"; break;
 785                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 786         }
 787         ndr_print_enum(ndr, name, "ENUM", val, r);
 788 }
 789
 790 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 791 {
 792         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 793         return NDR_ERR_SUCCESS;
 794 }
 795
 796 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 797 {
 798         uint16_t v;
 799         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 800         *r = v;
 801         return NDR_ERR_SUCCESS;
 802 }
 803
 804 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 805 {
 806         const char *val = NULL;
 807
 808         switch (r) {
 809                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 810                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 811         }
 812         ndr_print_enum(ndr, name, "ENUM", val, r);
 813 }
 814
 815 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 816 {
 817         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 818         return NDR_ERR_SUCCESS;
 819 }
 820
 821 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 822 {
 823         uint16_t v;
 824         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 825         *r = v;
 826         return NDR_ERR_SUCCESS;
 827 }
 828
 829 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 830 {
 831         const char *val = NULL;
 832
 833         switch (r) {
 834                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 835                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 836                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 837         }
 838         ndr_print_enum(ndr, name, "ENUM", val, r);
 839 }
 840
 841 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 842 {
 843         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 844         return NDR_ERR_SUCCESS;
 845 }
 846
 847 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 848 {
 849         uint16_t v;
 850         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 851         *r = v;
 852         return NDR_ERR_SUCCESS;
 853 }
 854
 855 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 856 {
 857         const char *val = NULL;
 858
 859         switch (r) {
 860                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 861                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 862                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 863                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 864         }
 865         ndr_print_enum(ndr, name, "ENUM", val, r);
 866 }
 867
 868 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 869 {
 870         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 871         return NDR_ERR_SUCCESS;
 872 }
 873
 874 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 875 {
 876         uint16_t v;
 877         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 878         *r = v;
 879         return NDR_ERR_SUCCESS;
 880 }
 881
 882 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 883 {
 884         const char *val = NULL;
 885
 886         switch (r) {
 887                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 888                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 889         }
 890         ndr_print_enum(ndr, name, "ENUM", val, r);
 891 }
 892
 893 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 894 {
 895         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 896         return NDR_ERR_SUCCESS;
 897 }
 898
 899 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 900 {
 901         uint32_t v;
 902         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 903         *r = v;
 904         return NDR_ERR_SUCCESS;
 905 }
 906
 907 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 908 {
 909         const char *val = NULL;
 910
 911         switch (r) {
 912                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 913                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 914         }
 915         ndr_print_enum(ndr, name, "ENUM", val, r);
 916 }
 917
 918 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 919 {
 920         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 921         return NDR_ERR_SUCCESS;
 922 }
 923
 924 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 925 {
 926         uint32_t v;
 927         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 928         *r = v;
 929         return NDR_ERR_SUCCESS;
 930 }
 931
 932 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 933 {
 934         const char *val = NULL;
 935
 936         switch (r) {
 937                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 938                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 939                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 940                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 941         }
 942         ndr_print_enum(ndr, name, "ENUM", val, r);
 943 }
 944
 945 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 946 {
 947         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 948         return NDR_ERR_SUCCESS;
 949 }
 950
 951 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 952 {
 953         uint32_t v;
 954         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 955         *r = v;
 956         return NDR_ERR_SUCCESS;
 957 }
 958
 959 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 960 {
 961         const char *val = NULL;
 962
 963         switch (r) {
 964                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 965                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 966                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 967                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 968         }
 969         ndr_print_enum(ndr, name, "ENUM", val, r);
 970 }
 971
 972 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 973 {
 974         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 975         return NDR_ERR_SUCCESS;
 976 }
 977
 978 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
 979 {
 980         uint32_t v;
 981         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 982         *r = v;
 983         return NDR_ERR_SUCCESS;
 984 }
 985
 986 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
 987 {
 988         const char *val = NULL;
 989
 990         switch (r) {
 991                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
 992                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
 993                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
 994         }
 995         ndr_print_enum(ndr, name, "ENUM", val, r);
 996 }
 997
 998 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
 999 {
1000         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1001         return NDR_ERR_SUCCESS;
1002 }
1003
1004 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1005 {
1006         uint32_t v;
1007         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1008         *r = v;
1009         return NDR_ERR_SUCCESS;
1010 }
1011
1012 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1013 {
1014         const char *val = NULL;
1015
1016         switch (r) {
1017                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1018                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1019                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1020                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1021                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1022                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1023                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1024                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1025                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1026                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1027         }
1028         ndr_print_enum(ndr, name, "ENUM", val, r);
1029 }
1030
1031 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1032 {
1033         if (ndr_flags & NDR_SCALARS) {
1034                 NDR_CHECK(ndr_push_align(ndr, 4));
1035                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1036                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1037                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1038                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1039                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1040                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1041                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1042                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1043                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1044                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1045                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1046                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1047                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1048                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1049                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1050                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1051                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1052                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1053                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1054                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1055                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1059                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1062                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1063                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1064                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1069                 {
1070                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1072                         {
1073                                 struct ndr_push *_ndr_driverextra_data;
1074                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1075                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1076                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1077                         }
1078                         ndr->flags = _flags_save_DATA_BLOB;
1079                 }
1080                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1081         }
1082         if (ndr_flags & NDR_BUFFERS) {
1083         }
1084         return NDR_ERR_SUCCESS;
1085 }
1086
1087 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1088 {
1089         uint32_t size_devicename_0 = 0;
1090         uint32_t size_formname_0 = 0;
1091         if (ndr_flags & NDR_SCALARS) {
1092                 NDR_CHECK(ndr_pull_align(ndr, 4));
1093                 size_devicename_0 = MAXDEVICENAME;
1094                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, size_devicename_0, sizeof(uint16_t), CH_UTF16));
1095                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1096                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1097                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1098                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1099                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1100                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1101                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1102                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1103                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1104                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1105                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1106                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1107                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1108                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1109                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1110                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1111                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1112                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1113                 size_formname_0 = MAXDEVICENAME;
1114                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, size_formname_0, sizeof(uint16_t), CH_UTF16));
1115                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1119                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1121                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1122                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1123                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1129                 {
1130                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1132                         {
1133                                 struct ndr_pull *_ndr_driverextra_data;
1134                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1135                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1136                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1137                         }
1138                         ndr->flags = _flags_save_DATA_BLOB;
1139                 }
1140                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1141         }
1142         if (ndr_flags & NDR_BUFFERS) {
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1148 {
1149         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1150         ndr->depth++;
1151         ndr_print_string(ndr, "devicename", r->devicename);
1152         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1153         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1154         ndr_print_uint16(ndr, "size", r->size);
1155         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1156         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1157         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1158         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1159         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1160         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1161         ndr_print_uint16(ndr, "scale", r->scale);
1162         ndr_print_uint16(ndr, "copies", r->copies);
1163         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1164         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1165         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1166         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1167         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1168         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1169         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1170         ndr_print_string(ndr, "formname", r->formname);
1171         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1172         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1173         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1174         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1175         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1176         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1177         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1178         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1179         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1180         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1181         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1182         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1183         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1184         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1185         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1186         ndr->depth--;
1187 }
1188
1189 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1190 {
1191         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1192 }
1193
1194 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1195 {
1196         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1197         return NDR_ERR_SUCCESS;
1198 }
1199
1200 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1201 {
1202         uint32_t v;
1203         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1204         *r = v;
1205         return NDR_ERR_SUCCESS;
1206 }
1207
1208 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1209 {
1210         ndr_print_uint32(ndr, name, r);
1211         ndr->depth++;
1212         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1214         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1215         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1216         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1217         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1218         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1219         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1220         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1221         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1222         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1223         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1224         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1225         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1226         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1231         ndr->depth--;
1232 }
1233
1234 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1235 {
1236         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1237         return NDR_ERR_SUCCESS;
1238 }
1239
1240 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1241 {
1242         uint32_t v;
1243         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1244         *r = v;
1245         return NDR_ERR_SUCCESS;
1246 }
1247
1248 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1249 {
1250         ndr_print_uint32(ndr, name, r);
1251         ndr->depth++;
1252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1268         ndr->depth--;
1269 }
1270
1271 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1272 {
1273         if (ndr_flags & NDR_SCALARS) {
1274                 NDR_CHECK(ndr_push_align(ndr, 5));
1275                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1276                 {
1277                         uint32_t _flags_save_string = ndr->flags;
1278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1279                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1280                         ndr->flags = _flags_save_string;
1281                 }
1282                 {
1283                         uint32_t _flags_save_string = ndr->flags;
1284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1285                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1286                         ndr->flags = _flags_save_string;
1287                 }
1288                 {
1289                         uint32_t _flags_save_string = ndr->flags;
1290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1291                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1292                         ndr->flags = _flags_save_string;
1293                 }
1294                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1295         }
1296         if (ndr_flags & NDR_BUFFERS) {
1297                 {
1298                         uint32_t _flags_save_string = ndr->flags;
1299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1300                         if (r->description) {
1301                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
1302                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1303                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
1304                         }
1305                         ndr->flags = _flags_save_string;
1306                 }
1307                 {
1308                         uint32_t _flags_save_string = ndr->flags;
1309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1310                         if (r->name) {
1311                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name));
1312                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1313                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name));
1314                         }
1315                         ndr->flags = _flags_save_string;
1316                 }
1317                 {
1318                         uint32_t _flags_save_string = ndr->flags;
1319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1320                         if (r->comment) {
1321                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1322                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1323                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1324                         }
1325                         ndr->flags = _flags_save_string;
1326                 }
1327         }
1328         return NDR_ERR_SUCCESS;
1329 }
1330
1331 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1332 {
1333         uint32_t _ptr_description;
1334         TALLOC_CTX *_mem_save_description_0;
1335         uint32_t _ptr_name;
1336         TALLOC_CTX *_mem_save_name_0;
1337         uint32_t _ptr_comment;
1338         TALLOC_CTX *_mem_save_comment_0;
1339         if (ndr_flags & NDR_SCALARS) {
1340                 NDR_CHECK(ndr_pull_align(ndr, 5));
1341                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1342                 {
1343                         uint32_t _flags_save_string = ndr->flags;
1344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1345                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1346                         if (_ptr_description) {
1347                                 NDR_PULL_ALLOC(ndr, r->description);
1348                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1349                         } else {
1350                                 r->description = NULL;
1351                         }
1352                         ndr->flags = _flags_save_string;
1353                 }
1354                 {
1355                         uint32_t _flags_save_string = ndr->flags;
1356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1357                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1358                         if (_ptr_name) {
1359                                 NDR_PULL_ALLOC(ndr, r->name);
1360                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1361                         } else {
1362                                 r->name = NULL;
1363                         }
1364                         ndr->flags = _flags_save_string;
1365                 }
1366                 {
1367                         uint32_t _flags_save_string = ndr->flags;
1368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1369                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1370                         if (_ptr_comment) {
1371                                 NDR_PULL_ALLOC(ndr, r->comment);
1372                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1373                         } else {
1374                                 r->comment = NULL;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1379         }
1380         if (ndr_flags & NDR_BUFFERS) {
1381                 {
1382                         uint32_t _flags_save_string = ndr->flags;
1383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1384                         if (r->description) {
1385                                 uint32_t _relative_save_offset;
1386                                 _relative_save_offset = ndr->offset;
1387                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1388                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1389                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1390                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1391                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1392                                 ndr->offset = _relative_save_offset;
1393                         }
1394                         ndr->flags = _flags_save_string;
1395                 }
1396                 {
1397                         uint32_t _flags_save_string = ndr->flags;
1398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1399                         if (r->name) {
1400                                 uint32_t _relative_save_offset;
1401                                 _relative_save_offset = ndr->offset;
1402                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1403                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1404                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1405                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1406                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1407                                 ndr->offset = _relative_save_offset;
1408                         }
1409                         ndr->flags = _flags_save_string;
1410                 }
1411                 {
1412                         uint32_t _flags_save_string = ndr->flags;
1413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1414                         if (r->comment) {
1415                                 uint32_t _relative_save_offset;
1416                                 _relative_save_offset = ndr->offset;
1417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1418                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1419                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1422                                 ndr->offset = _relative_save_offset;
1423                         }
1424                         ndr->flags = _flags_save_string;
1425                 }
1426         }
1427         return NDR_ERR_SUCCESS;
1428 }
1429
1430 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1431 {
1432         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1433         ndr->depth++;
1434         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1435         ndr_print_ptr(ndr, "description", r->description);
1436         ndr->depth++;
1437         if (r->description) {
1438                 ndr_print_string(ndr, "description", r->description);
1439         }
1440         ndr->depth--;
1441         ndr_print_ptr(ndr, "name", r->name);
1442         ndr->depth++;
1443         if (r->name) {
1444                 ndr_print_string(ndr, "name", r->name);
1445         }
1446         ndr->depth--;
1447         ndr_print_ptr(ndr, "comment", r->comment);
1448         ndr->depth++;
1449         if (r->comment) {
1450                 ndr_print_string(ndr, "comment", r->comment);
1451         }
1452         ndr->depth--;
1453         ndr->depth--;
1454 }
1455
1456 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1457 {
1458         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1459 }
1460
1461 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1462 {
1463         uint32_t _ptr_servername;
1464         TALLOC_CTX *_mem_save_servername_0;
1465         uint32_t _ptr_printername;
1466         TALLOC_CTX *_mem_save_printername_0;
1467         uint32_t _ptr_sharename;
1468         TALLOC_CTX *_mem_save_sharename_0;
1469         uint32_t _ptr_portname;
1470         TALLOC_CTX *_mem_save_portname_0;
1471         uint32_t _ptr_drivername;
1472         TALLOC_CTX *_mem_save_drivername_0;
1473         uint32_t _ptr_comment;
1474         TALLOC_CTX *_mem_save_comment_0;
1475         uint32_t _ptr_location;
1476         TALLOC_CTX *_mem_save_location_0;
1477         uint32_t _ptr_devmode;
1478         TALLOC_CTX *_mem_save_devmode_0;
1479         uint32_t _ptr_sepfile;
1480         TALLOC_CTX *_mem_save_sepfile_0;
1481         uint32_t _ptr_printprocessor;
1482         TALLOC_CTX *_mem_save_printprocessor_0;
1483         uint32_t _ptr_datatype;
1484         TALLOC_CTX *_mem_save_datatype_0;
1485         uint32_t _ptr_parameters;
1486         TALLOC_CTX *_mem_save_parameters_0;
1487         uint32_t _ptr_secdesc;
1488         TALLOC_CTX *_mem_save_secdesc_0;
1489         if (ndr_flags & NDR_SCALARS) {
1490                 NDR_CHECK(ndr_pull_align(ndr, 5));
1491                 {
1492                         uint32_t _flags_save_string = ndr->flags;
1493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1494                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1495                         if (_ptr_servername) {
1496                                 NDR_PULL_ALLOC(ndr, r->servername);
1497                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1498                         } else {
1499                                 r->servername = NULL;
1500                         }
1501                         ndr->flags = _flags_save_string;
1502                 }
1503                 {
1504                         uint32_t _flags_save_string = ndr->flags;
1505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1506                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1507                         if (_ptr_printername) {
1508                                 NDR_PULL_ALLOC(ndr, r->printername);
1509                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1510                         } else {
1511                                 r->printername = NULL;
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|LIBNDR_FLAG_ALIGN2);
1518                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1519                         if (_ptr_sharename) {
1520                                 NDR_PULL_ALLOC(ndr, r->sharename);
1521                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1522                         } else {
1523                                 r->sharename = NULL;
1524                         }
1525                         ndr->flags = _flags_save_string;
1526                 }
1527                 {
1528                         uint32_t _flags_save_string = ndr->flags;
1529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1530                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1531                         if (_ptr_portname) {
1532                                 NDR_PULL_ALLOC(ndr, r->portname);
1533                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1534                         } else {
1535                                 r->portname = NULL;
1536                         }
1537                         ndr->flags = _flags_save_string;
1538                 }
1539                 {
1540                         uint32_t _flags_save_string = ndr->flags;
1541                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1542                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1543                         if (_ptr_drivername) {
1544                                 NDR_PULL_ALLOC(ndr, r->drivername);
1545                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1546                         } else {
1547                                 r->drivername = NULL;
1548                         }
1549                         ndr->flags = _flags_save_string;
1550                 }
1551                 {
1552                         uint32_t _flags_save_string = ndr->flags;
1553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1554                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1555                         if (_ptr_comment) {
1556                                 NDR_PULL_ALLOC(ndr, r->comment);
1557                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1558                         } else {
1559                                 r->comment = NULL;
1560                         }
1561                         ndr->flags = _flags_save_string;
1562                 }
1563                 {
1564                         uint32_t _flags_save_string = ndr->flags;
1565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1566                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1567                         if (_ptr_location) {
1568                                 NDR_PULL_ALLOC(ndr, r->location);
1569                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1570                         } else {
1571                                 r->location = NULL;
1572                         }
1573                         ndr->flags = _flags_save_string;
1574                 }
1575                 {
1576                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1577                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1578                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1579                         if (_ptr_devmode) {
1580                                 NDR_PULL_ALLOC(ndr, r->devmode);
1581                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1582                         } else {
1583                                 r->devmode = NULL;
1584                         }
1585                         ndr->flags = _flags_save_spoolss_DeviceMode;
1586                 }
1587                 {
1588                         uint32_t _flags_save_string = ndr->flags;
1589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1590                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1591                         if (_ptr_sepfile) {
1592                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1593                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1594                         } else {
1595                                 r->sepfile = NULL;
1596                         }
1597                         ndr->flags = _flags_save_string;
1598                 }
1599                 {
1600                         uint32_t _flags_save_string = ndr->flags;
1601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1602                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1603                         if (_ptr_printprocessor) {
1604                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1605                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1606                         } else {
1607                                 r->printprocessor = NULL;
1608                         }
1609                         ndr->flags = _flags_save_string;
1610                 }
1611                 {
1612                         uint32_t _flags_save_string = ndr->flags;
1613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1614                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1615                         if (_ptr_datatype) {
1616                                 NDR_PULL_ALLOC(ndr, r->datatype);
1617                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1618                         } else {
1619                                 r->datatype = NULL;
1620                         }
1621                         ndr->flags = _flags_save_string;
1622                 }
1623                 {
1624                         uint32_t _flags_save_string = ndr->flags;
1625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1626                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1627                         if (_ptr_parameters) {
1628                                 NDR_PULL_ALLOC(ndr, r->parameters);
1629                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1630                         } else {
1631                                 r->parameters = NULL;
1632                         }
1633                         ndr->flags = _flags_save_string;
1634                 }
1635                 {
1636                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1638                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1639                         if (_ptr_secdesc) {
1640                                 NDR_PULL_ALLOC(ndr, r->secdesc);
1641                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1642                         } else {
1643                                 r->secdesc = NULL;
1644                         }
1645                         ndr->flags = _flags_save_spoolss_security_descriptor;
1646                 }
1647                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1649                 if (r->priority > 99) {
1650                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1651                 }
1652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1655                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1658                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1659         }
1660         if (ndr_flags & NDR_BUFFERS) {
1661                 {
1662                         uint32_t _flags_save_string = ndr->flags;
1663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1664                         if (r->servername) {
1665                                 uint32_t _relative_save_offset;
1666                                 _relative_save_offset = ndr->offset;
1667                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1668                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1669                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1670                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1671                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1672                                 ndr->offset = _relative_save_offset;
1673                         }
1674                         ndr->flags = _flags_save_string;
1675                 }
1676                 {
1677                         uint32_t _flags_save_string = ndr->flags;
1678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1679                         if (r->printername) {
1680                                 uint32_t _relative_save_offset;
1681                                 _relative_save_offset = ndr->offset;
1682                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1683                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1684                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1685                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1686                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1687                                 ndr->offset = _relative_save_offset;
1688                         }
1689                         ndr->flags = _flags_save_string;
1690                 }
1691                 {
1692                         uint32_t _flags_save_string = ndr->flags;
1693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1694                         if (r->sharename) {
1695                                 uint32_t _relative_save_offset;
1696                                 _relative_save_offset = ndr->offset;
1697                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1698                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1699                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1700                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1701                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1702                                 ndr->offset = _relative_save_offset;
1703                         }
1704                         ndr->flags = _flags_save_string;
1705                 }
1706                 {
1707                         uint32_t _flags_save_string = ndr->flags;
1708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1709                         if (r->portname) {
1710                                 uint32_t _relative_save_offset;
1711                                 _relative_save_offset = ndr->offset;
1712                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1713                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1714                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1715                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1716                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1717                                 ndr->offset = _relative_save_offset;
1718                         }
1719                         ndr->flags = _flags_save_string;
1720                 }
1721                 {
1722                         uint32_t _flags_save_string = ndr->flags;
1723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1724                         if (r->drivername) {
1725                                 uint32_t _relative_save_offset;
1726                                 _relative_save_offset = ndr->offset;
1727                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1728                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1729                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1730                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1731                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1732                                 ndr->offset = _relative_save_offset;
1733                         }
1734                         ndr->flags = _flags_save_string;
1735                 }
1736                 {
1737                         uint32_t _flags_save_string = ndr->flags;
1738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1739                         if (r->comment) {
1740                                 uint32_t _relative_save_offset;
1741                                 _relative_save_offset = ndr->offset;
1742                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1743                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1744                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1745                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1746                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1747                                 ndr->offset = _relative_save_offset;
1748                         }
1749                         ndr->flags = _flags_save_string;
1750                 }
1751                 {
1752                         uint32_t _flags_save_string = ndr->flags;
1753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1754                         if (r->location) {
1755                                 uint32_t _relative_save_offset;
1756                                 _relative_save_offset = ndr->offset;
1757                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1758                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1759                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1760                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1761                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1762                                 ndr->offset = _relative_save_offset;
1763                         }
1764                         ndr->flags = _flags_save_string;
1765                 }
1766                 {
1767                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1769                         if (r->devmode) {
1770                                 uint32_t _relative_save_offset;
1771                                 _relative_save_offset = ndr->offset;
1772                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1773                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1774                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1775                                 {
1776                                         struct ndr_pull *_ndr_devmode;
1777                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1778                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1779                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1780                                 }
1781                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1782                                 ndr->offset = _relative_save_offset;
1783                         }
1784                         ndr->flags = _flags_save_spoolss_DeviceMode;
1785                 }
1786                 {
1787                         uint32_t _flags_save_string = ndr->flags;
1788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1789                         if (r->sepfile) {
1790                                 uint32_t _relative_save_offset;
1791                                 _relative_save_offset = ndr->offset;
1792                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1793                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1794                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1795                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1796                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1797                                 ndr->offset = _relative_save_offset;
1798                         }
1799                         ndr->flags = _flags_save_string;
1800                 }
1801                 {
1802                         uint32_t _flags_save_string = ndr->flags;
1803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1804                         if (r->printprocessor) {
1805                                 uint32_t _relative_save_offset;
1806                                 _relative_save_offset = ndr->offset;
1807                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1808                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1809                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1810                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1811                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1812                                 ndr->offset = _relative_save_offset;
1813                         }
1814                         ndr->flags = _flags_save_string;
1815                 }
1816                 {
1817                         uint32_t _flags_save_string = ndr->flags;
1818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1819                         if (r->datatype) {
1820                                 uint32_t _relative_save_offset;
1821                                 _relative_save_offset = ndr->offset;
1822                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1823                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1824                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1825                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1826                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1827                                 ndr->offset = _relative_save_offset;
1828                         }
1829                         ndr->flags = _flags_save_string;
1830                 }
1831                 {
1832                         uint32_t _flags_save_string = ndr->flags;
1833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1834                         if (r->parameters) {
1835                                 uint32_t _relative_save_offset;
1836                                 _relative_save_offset = ndr->offset;
1837                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1838                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1839                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1840                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1841                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1842                                 ndr->offset = _relative_save_offset;
1843                         }
1844                         ndr->flags = _flags_save_string;
1845                 }
1846                 {
1847                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1849                         if (r->secdesc) {
1850                                 uint32_t _relative_save_offset;
1851                                 _relative_save_offset = ndr->offset;
1852                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1853                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1854                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1855                                 {
1856                                         struct ndr_pull *_ndr_secdesc;
1857                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1858                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1859                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1860                                 }
1861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1862                                 ndr->offset = _relative_save_offset;
1863                         }
1864                         ndr->flags = _flags_save_spoolss_security_descriptor;
1865                 }
1866         }
1867         return NDR_ERR_SUCCESS;
1868 }
1869
1870 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1871 {
1872         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1873         ndr->depth++;
1874         ndr_print_ptr(ndr, "servername", r->servername);
1875         ndr->depth++;
1876         if (r->servername) {
1877                 ndr_print_string(ndr, "servername", r->servername);
1878         }
1879         ndr->depth--;
1880         ndr_print_ptr(ndr, "printername", r->printername);
1881         ndr->depth++;
1882         if (r->printername) {
1883                 ndr_print_string(ndr, "printername", r->printername);
1884         }
1885         ndr->depth--;
1886         ndr_print_ptr(ndr, "sharename", r->sharename);
1887         ndr->depth++;
1888         if (r->sharename) {
1889                 ndr_print_string(ndr, "sharename", r->sharename);
1890         }
1891         ndr->depth--;
1892         ndr_print_ptr(ndr, "portname", r->portname);
1893         ndr->depth++;
1894         if (r->portname) {
1895                 ndr_print_string(ndr, "portname", r->portname);
1896         }
1897         ndr->depth--;
1898         ndr_print_ptr(ndr, "drivername", r->drivername);
1899         ndr->depth++;
1900         if (r->drivername) {
1901                 ndr_print_string(ndr, "drivername", r->drivername);
1902         }
1903         ndr->depth--;
1904         ndr_print_ptr(ndr, "comment", r->comment);
1905         ndr->depth++;
1906         if (r->comment) {
1907                 ndr_print_string(ndr, "comment", r->comment);
1908         }
1909         ndr->depth--;
1910         ndr_print_ptr(ndr, "location", r->location);
1911         ndr->depth++;
1912         if (r->location) {
1913                 ndr_print_string(ndr, "location", r->location);
1914         }
1915         ndr->depth--;
1916         ndr_print_ptr(ndr, "devmode", r->devmode);
1917         ndr->depth++;
1918         if (r->devmode) {
1919                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1920         }
1921         ndr->depth--;
1922         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1923         ndr->depth++;
1924         if (r->sepfile) {
1925                 ndr_print_string(ndr, "sepfile", r->sepfile);
1926         }
1927         ndr->depth--;
1928         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1929         ndr->depth++;
1930         if (r->printprocessor) {
1931                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1932         }
1933         ndr->depth--;
1934         ndr_print_ptr(ndr, "datatype", r->datatype);
1935         ndr->depth++;
1936         if (r->datatype) {
1937                 ndr_print_string(ndr, "datatype", r->datatype);
1938         }
1939         ndr->depth--;
1940         ndr_print_ptr(ndr, "parameters", r->parameters);
1941         ndr->depth++;
1942         if (r->parameters) {
1943                 ndr_print_string(ndr, "parameters", r->parameters);
1944         }
1945         ndr->depth--;
1946         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1947         ndr->depth++;
1948         if (r->secdesc) {
1949                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
1950         }
1951         ndr->depth--;
1952         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1953         ndr_print_uint32(ndr, "priority", r->priority);
1954         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1955         ndr_print_uint32(ndr, "starttime", r->starttime);
1956         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1957         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1958         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1959         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1960         ndr->depth--;
1961 }
1962
1963 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
1964 {
1965         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
1966 }
1967
1968 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1969 {
1970         if (ndr_flags & NDR_SCALARS) {
1971                 NDR_CHECK(ndr_push_align(ndr, 5));
1972                 {
1973                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1976                         ndr->flags = _flags_save_spoolss_security_descriptor;
1977                 }
1978                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1979         }
1980         if (ndr_flags & NDR_BUFFERS) {
1981                 {
1982                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1984                         if (r->secdesc) {
1985                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
1986                                 {
1987                                         struct ndr_push *_ndr_secdesc;
1988                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1989                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1990                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1991                                 }
1992                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
1993                         }
1994                         ndr->flags = _flags_save_spoolss_security_descriptor;
1995                 }
1996         }
1997         return NDR_ERR_SUCCESS;
1998 }
1999
2000 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2001 {
2002         uint32_t _ptr_secdesc;
2003         TALLOC_CTX *_mem_save_secdesc_0;
2004         if (ndr_flags & NDR_SCALARS) {
2005                 NDR_CHECK(ndr_pull_align(ndr, 5));
2006                 {
2007                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2009                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2010                         if (_ptr_secdesc) {
2011                                 NDR_PULL_ALLOC(ndr, r->secdesc);
2012                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2013                         } else {
2014                                 r->secdesc = NULL;
2015                         }
2016                         ndr->flags = _flags_save_spoolss_security_descriptor;
2017                 }
2018                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2019         }
2020         if (ndr_flags & NDR_BUFFERS) {
2021                 {
2022                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2024                         if (r->secdesc) {
2025                                 uint32_t _relative_save_offset;
2026                                 _relative_save_offset = ndr->offset;
2027                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2028                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2029                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2030                                 {
2031                                         struct ndr_pull *_ndr_secdesc;
2032                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2033                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2034                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2035                                 }
2036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2037                                 ndr->offset = _relative_save_offset;
2038                         }
2039                         ndr->flags = _flags_save_spoolss_security_descriptor;
2040                 }
2041         }
2042         return NDR_ERR_SUCCESS;
2043 }
2044
2045 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2046 {
2047         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2048         ndr->depth++;
2049         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2050         ndr->depth++;
2051         if (r->secdesc) {
2052                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
2053         }
2054         ndr->depth--;
2055         ndr->depth--;
2056 }
2057
2058 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2059 {
2060         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2061 }
2062
2063 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2064 {
2065         if (ndr_flags & NDR_SCALARS) {
2066                 NDR_CHECK(ndr_push_align(ndr, 5));
2067                 {
2068                         uint32_t _flags_save_string = ndr->flags;
2069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2070                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2071                         ndr->flags = _flags_save_string;
2072                 }
2073                 {
2074                         uint32_t _flags_save_string = ndr->flags;
2075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2076                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2077                         ndr->flags = _flags_save_string;
2078                 }
2079                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2080                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2081         }
2082         if (ndr_flags & NDR_BUFFERS) {
2083                 {
2084                         uint32_t _flags_save_string = ndr->flags;
2085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2086                         if (r->printername) {
2087                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2088                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2089                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2090                         }
2091                         ndr->flags = _flags_save_string;
2092                 }
2093                 {
2094                         uint32_t _flags_save_string = ndr->flags;
2095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2096                         if (r->servername) {
2097                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
2098                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2099                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
2100                         }
2101                         ndr->flags = _flags_save_string;
2102                 }
2103         }
2104         return NDR_ERR_SUCCESS;
2105 }
2106
2107 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2108 {
2109         uint32_t _ptr_printername;
2110         TALLOC_CTX *_mem_save_printername_0;
2111         uint32_t _ptr_servername;
2112         TALLOC_CTX *_mem_save_servername_0;
2113         if (ndr_flags & NDR_SCALARS) {
2114                 NDR_CHECK(ndr_pull_align(ndr, 5));
2115                 {
2116                         uint32_t _flags_save_string = ndr->flags;
2117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2119                         if (_ptr_printername) {
2120                                 NDR_PULL_ALLOC(ndr, r->printername);
2121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2122                         } else {
2123                                 r->printername = NULL;
2124                         }
2125                         ndr->flags = _flags_save_string;
2126                 }
2127                 {
2128                         uint32_t _flags_save_string = ndr->flags;
2129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2131                         if (_ptr_servername) {
2132                                 NDR_PULL_ALLOC(ndr, r->servername);
2133                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2134                         } else {
2135                                 r->servername = NULL;
2136                         }
2137                         ndr->flags = _flags_save_string;
2138                 }
2139                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2140                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2141         }
2142         if (ndr_flags & NDR_BUFFERS) {
2143                 {
2144                         uint32_t _flags_save_string = ndr->flags;
2145                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2146                         if (r->printername) {
2147                                 uint32_t _relative_save_offset;
2148                                 _relative_save_offset = ndr->offset;
2149                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2150                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2151                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2152                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2153                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2154                                 ndr->offset = _relative_save_offset;
2155                         }
2156                         ndr->flags = _flags_save_string;
2157                 }
2158                 {
2159                         uint32_t _flags_save_string = ndr->flags;
2160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2161                         if (r->servername) {
2162                                 uint32_t _relative_save_offset;
2163                                 _relative_save_offset = ndr->offset;
2164                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2165                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2166                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2167                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2168                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2169                                 ndr->offset = _relative_save_offset;
2170                         }
2171                         ndr->flags = _flags_save_string;
2172                 }
2173         }
2174         return NDR_ERR_SUCCESS;
2175 }
2176
2177 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2178 {
2179         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2180         ndr->depth++;
2181         ndr_print_ptr(ndr, "printername", r->printername);
2182         ndr->depth++;
2183         if (r->printername) {
2184                 ndr_print_string(ndr, "printername", r->printername);
2185         }
2186         ndr->depth--;
2187         ndr_print_ptr(ndr, "servername", r->servername);
2188         ndr->depth++;
2189         if (r->servername) {
2190                 ndr_print_string(ndr, "servername", r->servername);
2191         }
2192         ndr->depth--;
2193         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2194         ndr->depth--;
2195 }
2196
2197 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2198 {
2199         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2200 }
2201
2202 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2203 {
2204         if (ndr_flags & NDR_SCALARS) {
2205                 NDR_CHECK(ndr_push_align(ndr, 5));
2206                 {
2207                         uint32_t _flags_save_string = ndr->flags;
2208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2210                         ndr->flags = _flags_save_string;
2211                 }
2212                 {
2213                         uint32_t _flags_save_string = ndr->flags;
2214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2216                         ndr->flags = _flags_save_string;
2217                 }
2218                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2221                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2222         }
2223         if (ndr_flags & NDR_BUFFERS) {
2224                 {
2225                         uint32_t _flags_save_string = ndr->flags;
2226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2227                         if (r->printername) {
2228                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2229                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2230                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2231                         }
2232                         ndr->flags = _flags_save_string;
2233                 }
2234                 {
2235                         uint32_t _flags_save_string = ndr->flags;
2236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2237                         if (r->portname) {
2238                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
2239                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2240                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
2241                         }
2242                         ndr->flags = _flags_save_string;
2243                 }
2244         }
2245         return NDR_ERR_SUCCESS;
2246 }
2247
2248 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2249 {
2250         uint32_t _ptr_printername;
2251         TALLOC_CTX *_mem_save_printername_0;
2252         uint32_t _ptr_portname;
2253         TALLOC_CTX *_mem_save_portname_0;
2254         if (ndr_flags & NDR_SCALARS) {
2255                 NDR_CHECK(ndr_pull_align(ndr, 5));
2256                 {
2257                         uint32_t _flags_save_string = ndr->flags;
2258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2259                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2260                         if (_ptr_printername) {
2261                                 NDR_PULL_ALLOC(ndr, r->printername);
2262                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2263                         } else {
2264                                 r->printername = NULL;
2265                         }
2266                         ndr->flags = _flags_save_string;
2267                 }
2268                 {
2269                         uint32_t _flags_save_string = ndr->flags;
2270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2271                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2272                         if (_ptr_portname) {
2273                                 NDR_PULL_ALLOC(ndr, r->portname);
2274                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2275                         } else {
2276                                 r->portname = NULL;
2277                         }
2278                         ndr->flags = _flags_save_string;
2279                 }
2280                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2283                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2284         }
2285         if (ndr_flags & NDR_BUFFERS) {
2286                 {
2287                         uint32_t _flags_save_string = ndr->flags;
2288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2289                         if (r->printername) {
2290                                 uint32_t _relative_save_offset;
2291                                 _relative_save_offset = ndr->offset;
2292                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2293                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2294                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2295                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2296                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2297                                 ndr->offset = _relative_save_offset;
2298                         }
2299                         ndr->flags = _flags_save_string;
2300                 }
2301                 {
2302                         uint32_t _flags_save_string = ndr->flags;
2303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2304                         if (r->portname) {
2305                                 uint32_t _relative_save_offset;
2306                                 _relative_save_offset = ndr->offset;
2307                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2308                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2309                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2310                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2311                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2312                                 ndr->offset = _relative_save_offset;
2313                         }
2314                         ndr->flags = _flags_save_string;
2315                 }
2316         }
2317         return NDR_ERR_SUCCESS;
2318 }
2319
2320 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2321 {
2322         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2323         ndr->depth++;
2324         ndr_print_ptr(ndr, "printername", r->printername);
2325         ndr->depth++;
2326         if (r->printername) {
2327                 ndr_print_string(ndr, "printername", r->printername);
2328         }
2329         ndr->depth--;
2330         ndr_print_ptr(ndr, "portname", r->portname);
2331         ndr->depth++;
2332         if (r->portname) {
2333                 ndr_print_string(ndr, "portname", r->portname);
2334         }
2335         ndr->depth--;
2336         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2337         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2338         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2339         ndr->depth--;
2340 }
2341
2342 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2343 {
2344         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2345 }
2346
2347 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2348 {
2349         if (ndr_flags & NDR_SCALARS) {
2350                 NDR_CHECK(ndr_push_align(ndr, 4));
2351                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2352                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2353         }
2354         if (ndr_flags & NDR_BUFFERS) {
2355         }
2356         return NDR_ERR_SUCCESS;
2357 }
2358
2359 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2360 {
2361         if (ndr_flags & NDR_SCALARS) {
2362                 NDR_CHECK(ndr_pull_align(ndr, 4));
2363                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2364                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2365         }
2366         if (ndr_flags & NDR_BUFFERS) {
2367         }
2368         return NDR_ERR_SUCCESS;
2369 }
2370
2371 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2372 {
2373         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2374         ndr->depth++;
2375         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2376         ndr->depth--;
2377 }
2378
2379 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2380 {
2381         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2382 }
2383
2384 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2385 {
2386         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2387         return NDR_ERR_SUCCESS;
2388 }
2389
2390 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2391 {
2392         uint32_t v;
2393         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2394         *r = v;
2395         return NDR_ERR_SUCCESS;
2396 }
2397
2398 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2399 {
2400         ndr_print_uint32(ndr, name, r);
2401         ndr->depth++;
2402         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2403         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2404         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2405         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2406         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2407         ndr->depth--;
2408 }
2409
2410 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2411 {
2412         if (ndr_flags & NDR_SCALARS) {
2413                 NDR_CHECK(ndr_push_align(ndr, 5));
2414                 {
2415                         uint32_t _flags_save_string = ndr->flags;
2416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2417                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2418                         ndr->flags = _flags_save_string;
2419                 }
2420                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2421                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2422         }
2423         if (ndr_flags & NDR_BUFFERS) {
2424                 {
2425                         uint32_t _flags_save_string = ndr->flags;
2426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2427                         if (r->guid) {
2428                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->guid));
2429                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2430                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->guid));
2431                         }
2432                         ndr->flags = _flags_save_string;
2433                 }
2434         }
2435         return NDR_ERR_SUCCESS;
2436 }
2437
2438 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2439 {
2440         uint32_t _ptr_guid;
2441         TALLOC_CTX *_mem_save_guid_0;
2442         if (ndr_flags & NDR_SCALARS) {
2443                 NDR_CHECK(ndr_pull_align(ndr, 5));
2444                 {
2445                         uint32_t _flags_save_string = ndr->flags;
2446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2447                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2448                         if (_ptr_guid) {
2449                                 NDR_PULL_ALLOC(ndr, r->guid);
2450                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2451                         } else {
2452                                 r->guid = NULL;
2453                         }
2454                         ndr->flags = _flags_save_string;
2455                 }
2456                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2457                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2458         }
2459         if (ndr_flags & NDR_BUFFERS) {
2460                 {
2461                         uint32_t _flags_save_string = ndr->flags;
2462                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2463                         if (r->guid) {
2464                                 uint32_t _relative_save_offset;
2465                                 _relative_save_offset = ndr->offset;
2466                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2467                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2468                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2469                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2470                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2471                                 ndr->offset = _relative_save_offset;
2472                         }
2473                         ndr->flags = _flags_save_string;
2474                 }
2475         }
2476         return NDR_ERR_SUCCESS;
2477 }
2478
2479 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2480 {
2481         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2482         ndr->depth++;
2483         ndr_print_ptr(ndr, "guid", r->guid);
2484         ndr->depth++;
2485         if (r->guid) {
2486                 ndr_print_string(ndr, "guid", r->guid);
2487         }
2488         ndr->depth--;
2489         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2490         ndr->depth--;
2491 }
2492
2493 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2494 {
2495         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2496 }
2497
2498 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2499 {
2500         if (ndr_flags & NDR_SCALARS) {
2501                 NDR_CHECK(ndr_push_align(ndr, 5));
2502                 {
2503                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2505                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2506                         ndr->flags = _flags_save_spoolss_DeviceMode;
2507                 }
2508                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2509         }
2510         if (ndr_flags & NDR_BUFFERS) {
2511                 {
2512                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2514                         if (r->devmode) {
2515                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
2516                                 {
2517                                         struct ndr_push *_ndr_devmode;
2518                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2519                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2520                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2521                                 }
2522                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
2523                         }
2524                         ndr->flags = _flags_save_spoolss_DeviceMode;
2525                 }
2526         }
2527         return NDR_ERR_SUCCESS;
2528 }
2529
2530 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2531 {
2532         uint32_t _ptr_devmode;
2533         TALLOC_CTX *_mem_save_devmode_0;
2534         if (ndr_flags & NDR_SCALARS) {
2535                 NDR_CHECK(ndr_pull_align(ndr, 5));
2536                 {
2537                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2539                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2540                         if (_ptr_devmode) {
2541                                 NDR_PULL_ALLOC(ndr, r->devmode);
2542                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2543                         } else {
2544                                 r->devmode = NULL;
2545                         }
2546                         ndr->flags = _flags_save_spoolss_DeviceMode;
2547                 }
2548                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2549         }
2550         if (ndr_flags & NDR_BUFFERS) {
2551                 {
2552                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2554                         if (r->devmode) {
2555                                 uint32_t _relative_save_offset;
2556                                 _relative_save_offset = ndr->offset;
2557                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2558                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2559                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2560                                 {
2561                                         struct ndr_pull *_ndr_devmode;
2562                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2563                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2564                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2565                                 }
2566                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2567                                 ndr->offset = _relative_save_offset;
2568                         }
2569                         ndr->flags = _flags_save_spoolss_DeviceMode;
2570                 }
2571         }
2572         return NDR_ERR_SUCCESS;
2573 }
2574
2575 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2576 {
2577         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2578         ndr->depth++;
2579         ndr_print_ptr(ndr, "devmode", r->devmode);
2580         ndr->depth++;
2581         if (r->devmode) {
2582                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2583         }
2584         ndr->depth--;
2585         ndr->depth--;
2586 }
2587
2588 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2589 {
2590         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2591         {
2592                 uint32_t _flags_save_UNION = ndr->flags;
2593                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2594                 if (ndr_flags & NDR_SCALARS) {
2595                         int level = ndr_push_get_switch_value(ndr, r);
2596                         NDR_CHECK(ndr_push_union_align(ndr, 5));
2597                         switch (level) {
2598                                 case 0: {
2599                                         NDR_CHECK(ndr_push_align(ndr, 5));
2600                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2601                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2602                                 break; }
2603
2604                                 case 1: {
2605                                         NDR_CHECK(ndr_push_align(ndr, 5));
2606                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2607                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2608                                 break; }
2609
2610                                 case 2: {
2611                                         NDR_CHECK(ndr_push_align(ndr, 5));
2612                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2613                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2614                                 break; }
2615
2616                                 case 3: {
2617                                         NDR_CHECK(ndr_push_align(ndr, 5));
2618                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2619                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2620                                 break; }
2621
2622                                 case 4: {
2623                                         NDR_CHECK(ndr_push_align(ndr, 5));
2624                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2625                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2626                                 break; }
2627
2628                                 case 5: {
2629                                         NDR_CHECK(ndr_push_align(ndr, 5));
2630                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2631                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2632                                 break; }
2633
2634                                 case 6: {
2635                                         NDR_CHECK(ndr_push_align(ndr, 4));
2636                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2637                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2638                                 break; }
2639
2640                                 case 7: {
2641                                         NDR_CHECK(ndr_push_align(ndr, 5));
2642                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2643                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2644                                 break; }
2645
2646                                 case 8: {
2647                                         NDR_CHECK(ndr_push_align(ndr, 5));
2648                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2649                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2650                                 break; }
2651
2652                                 case 9: {
2653                                         NDR_CHECK(ndr_push_align(ndr, 5));
2654                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2655                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2656                                 break; }
2657
2658                                 default: {
2659                                 break; }
2660
2661                         }
2662                 }
2663                 if (ndr_flags & NDR_BUFFERS) {
2664                         int level = ndr_push_get_switch_value(ndr, r);
2665                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2666                         switch (level) {
2667                                 case 0:
2668                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2669                                 break;
2670
2671                                 case 1:
2672                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2673                                 break;
2674
2675                                 case 2:
2676                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2677                                 break;
2678
2679                                 case 3:
2680                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2681                                 break;
2682
2683                                 case 4:
2684                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2685                                 break;
2686
2687                                 case 5:
2688                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2689                                 break;
2690
2691                                 case 6:
2692                                 break;
2693
2694                                 case 7:
2695                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2696                                 break;
2697
2698                                 case 8:
2699                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2700                                 break;
2701
2702                                 case 9:
2703                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2704                                 break;
2705
2706                                 default:
2707                                 break;
2708
2709                         }
2710                 }
2711                 ndr->flags = _flags_save_UNION;
2712         }
2713         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2714         return NDR_ERR_SUCCESS;
2715 }
2716
2717 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2718 {
2719         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2720         int level;
2721         {
2722                 uint32_t _flags_save_UNION = ndr->flags;
2723                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2724                 level = ndr_pull_get_switch_value(ndr, r);
2725                 if (ndr_flags & NDR_SCALARS) {
2726                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
2727                         switch (level) {
2728                                 case 0: {
2729                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2730                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2731                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2732                                 break; }
2733
2734                                 case 1: {
2735                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2736                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2737                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2738                                 break; }
2739
2740                                 case 2: {
2741                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2742                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2743                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2744                                 break; }
2745
2746                                 case 3: {
2747                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2748                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2749                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2750                                 break; }
2751
2752                                 case 4: {
2753                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2754                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2755                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2756                                 break; }
2757
2758                                 case 5: {
2759                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2760                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2761                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2762                                 break; }
2763
2764                                 case 6: {
2765                                         NDR_CHECK(ndr_pull_align(ndr, 4));
2766                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2767                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2768                                 break; }
2769
2770                                 case 7: {
2771                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2772                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2773                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2774                                 break; }
2775
2776                                 case 8: {
2777                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2778                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2779                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2780                                 break; }
2781
2782                                 case 9: {
2783                                         NDR_CHECK(ndr_pull_align(ndr, 5));
2784                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2785                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2786                                 break; }
2787
2788                                 default: {
2789                                 break; }
2790
2791                         }
2792                 }
2793                 if (ndr_flags & NDR_BUFFERS) {
2794                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2795                         switch (level) {
2796                                 case 0:
2797                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2798                                 break;
2799
2800                                 case 1:
2801                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2802                                 break;
2803
2804                                 case 2:
2805                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2806                                 break;
2807
2808                                 case 3:
2809                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2810                                 break;
2811
2812                                 case 4:
2813                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2814                                 break;
2815
2816                                 case 5:
2817                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2818                                 break;
2819
2820                                 case 6:
2821                                 break;
2822
2823                                 case 7:
2824                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2825                                 break;
2826
2827                                 case 8:
2828                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2829                                 break;
2830
2831                                 case 9:
2832                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2833                                 break;
2834
2835                                 default:
2836                                 break;
2837
2838                         }
2839                 }
2840                 ndr->flags = _flags_save_UNION;
2841         }
2842         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2843         return NDR_ERR_SUCCESS;
2844 }
2845
2846 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2847 {
2848         int level;
2849         {
2850                 uint32_t _flags_save_UNION = ndr->flags;
2851                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2852                 level = ndr_print_get_switch_value(ndr, r);
2853                 ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2854                 switch (level) {
2855                         case 0:
2856                                 ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2857                         break;
2858
2859                         case 1:
2860                                 ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2861                         break;
2862
2863                         case 2:
2864                                 ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2865                         break;
2866
2867                         case 3:
2868                                 ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2869                         break;
2870
2871                         case 4:
2872                                 ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2873                         break;
2874
2875                         case 5:
2876                                 ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2877                         break;
2878
2879                         case 6:
2880                                 ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2881                         break;
2882
2883                         case 7:
2884                                 ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2885                         break;
2886
2887                         case 8:
2888                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2889                         break;
2890
2891                         case 9:
2892                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2893                         break;
2894
2895                         default:
2896                         break;
2897
2898                 }
2899                 ndr->flags = _flags_save_UNION;
2900         }
2901 }
2902
2903 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2904 {
2905         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
2906         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2907 }
2908
2909 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2910 {
2911         if (ndr_flags & NDR_SCALARS) {
2912                 NDR_CHECK(ndr_push_align(ndr, 5));
2913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2914                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2915                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2916         }
2917         if (ndr_flags & NDR_BUFFERS) {
2918                 if (r->devmode) {
2919                         {
2920                                 struct ndr_push *_ndr_devmode;
2921                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2922                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2923                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2924                         }
2925                 }
2926         }
2927         return NDR_ERR_SUCCESS;
2928 }
2929
2930 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2931 {
2932         uint32_t _ptr_devmode;
2933         TALLOC_CTX *_mem_save_devmode_0;
2934         if (ndr_flags & NDR_SCALARS) {
2935                 NDR_CHECK(ndr_pull_align(ndr, 5));
2936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2937                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2938                 if (_ptr_devmode) {
2939                         NDR_PULL_ALLOC(ndr, r->devmode);
2940                 } else {
2941                         r->devmode = NULL;
2942                 }
2943                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2944         }
2945         if (ndr_flags & NDR_BUFFERS) {
2946                 if (r->devmode) {
2947                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2948                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2949                         {
2950                                 struct ndr_pull *_ndr_devmode;
2951                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2952                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2953                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2954                         }
2955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2956                 }
2957         }
2958         return NDR_ERR_SUCCESS;
2959 }
2960
2961 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2962 {
2963         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2964         ndr->depth++;
2965         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);
2966         ndr_print_ptr(ndr, "devmode", r->devmode);
2967         ndr->depth++;
2968         if (r->devmode) {
2969                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2970         }
2971         ndr->depth--;
2972         ndr->depth--;
2973 }
2974
2975 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2976 {
2977         if (ndr_flags & NDR_SCALARS) {
2978                 NDR_CHECK(ndr_push_align(ndr, 5));
2979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2980                 {
2981                         uint32_t _flags_save_string = ndr->flags;
2982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2983                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2984                         ndr->flags = _flags_save_string;
2985                 }
2986                 {
2987                         uint32_t _flags_save_string = ndr->flags;
2988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2989                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2990                         ndr->flags = _flags_save_string;
2991                 }
2992                 {
2993                         uint32_t _flags_save_string = ndr->flags;
2994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2996                         ndr->flags = _flags_save_string;
2997                 }
2998                 {
2999                         uint32_t _flags_save_string = ndr->flags;
3000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3002                         ndr->flags = _flags_save_string;
3003                 }
3004                 {
3005                         uint32_t _flags_save_string = ndr->flags;
3006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3008                         ndr->flags = _flags_save_string;
3009                 }
3010                 {
3011                         uint32_t _flags_save_string = ndr->flags;
3012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3014                         ndr->flags = _flags_save_string;
3015                 }
3016                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3021                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3022                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3023         }
3024         if (ndr_flags & NDR_BUFFERS) {
3025                 {
3026                         uint32_t _flags_save_string = ndr->flags;
3027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3028                         if (r->printer_name) {
3029                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3030                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3031                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3032                         }
3033                         ndr->flags = _flags_save_string;
3034                 }
3035                 {
3036                         uint32_t _flags_save_string = ndr->flags;
3037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3038                         if (r->server_name) {
3039                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3041                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3042                         }
3043                         ndr->flags = _flags_save_string;
3044                 }
3045                 {
3046                         uint32_t _flags_save_string = ndr->flags;
3047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3048                         if (r->user_name) {
3049                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3050                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3051                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3052                         }
3053                         ndr->flags = _flags_save_string;
3054                 }
3055                 {
3056                         uint32_t _flags_save_string = ndr->flags;
3057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3058                         if (r->document_name) {
3059                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3060                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3061                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3062                         }
3063                         ndr->flags = _flags_save_string;
3064                 }
3065                 {
3066                         uint32_t _flags_save_string = ndr->flags;
3067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3068                         if (r->data_type) {
3069                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3070                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3071                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3072                         }
3073                         ndr->flags = _flags_save_string;
3074                 }
3075                 {
3076                         uint32_t _flags_save_string = ndr->flags;
3077                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3078                         if (r->text_status) {
3079                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3080                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3081                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3082                         }
3083                         ndr->flags = _flags_save_string;
3084                 }
3085         }
3086         return NDR_ERR_SUCCESS;
3087 }
3088
3089 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3090 {
3091         uint32_t _ptr_printer_name;
3092         TALLOC_CTX *_mem_save_printer_name_0;
3093         uint32_t _ptr_server_name;
3094         TALLOC_CTX *_mem_save_server_name_0;
3095         uint32_t _ptr_user_name;
3096         TALLOC_CTX *_mem_save_user_name_0;
3097         uint32_t _ptr_document_name;
3098         TALLOC_CTX *_mem_save_document_name_0;
3099         uint32_t _ptr_data_type;
3100         TALLOC_CTX *_mem_save_data_type_0;
3101         uint32_t _ptr_text_status;
3102         TALLOC_CTX *_mem_save_text_status_0;
3103         if (ndr_flags & NDR_SCALARS) {
3104                 NDR_CHECK(ndr_pull_align(ndr, 5));
3105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3106                 {
3107                         uint32_t _flags_save_string = ndr->flags;
3108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3109                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3110                         if (_ptr_printer_name) {
3111                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3112                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3113                         } else {
3114                                 r->printer_name = NULL;
3115                         }
3116                         ndr->flags = _flags_save_string;
3117                 }
3118                 {
3119                         uint32_t _flags_save_string = ndr->flags;
3120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3121                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3122                         if (_ptr_server_name) {
3123                                 NDR_PULL_ALLOC(ndr, r->server_name);
3124                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3125                         } else {
3126                                 r->server_name = NULL;
3127                         }
3128                         ndr->flags = _flags_save_string;
3129                 }
3130                 {
3131                         uint32_t _flags_save_string = ndr->flags;
3132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3133                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3134                         if (_ptr_user_name) {
3135                                 NDR_PULL_ALLOC(ndr, r->user_name);
3136                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3137                         } else {
3138                                 r->user_name = NULL;
3139                         }
3140                         ndr->flags = _flags_save_string;
3141                 }
3142                 {
3143                         uint32_t _flags_save_string = ndr->flags;
3144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3145                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3146                         if (_ptr_document_name) {
3147                                 NDR_PULL_ALLOC(ndr, r->document_name);
3148                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3149                         } else {
3150                                 r->document_name = NULL;
3151                         }
3152                         ndr->flags = _flags_save_string;
3153                 }
3154                 {
3155                         uint32_t _flags_save_string = ndr->flags;
3156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3157                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3158                         if (_ptr_data_type) {
3159                                 NDR_PULL_ALLOC(ndr, r->data_type);
3160                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3161                         } else {
3162                                 r->data_type = NULL;
3163                         }
3164                         ndr->flags = _flags_save_string;
3165                 }
3166                 {
3167                         uint32_t _flags_save_string = ndr->flags;
3168                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3169                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3170                         if (_ptr_text_status) {
3171                                 NDR_PULL_ALLOC(ndr, r->text_status);
3172                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3173                         } else {
3174                                 r->text_status = NULL;
3175                         }
3176                         ndr->flags = _flags_save_string;
3177                 }
3178                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3180                 if (r->priority > 99) {
3181                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3182                 }
3183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3186                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3187                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3188         }
3189         if (ndr_flags & NDR_BUFFERS) {
3190                 {
3191                         uint32_t _flags_save_string = ndr->flags;
3192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3193                         if (r->printer_name) {
3194                                 uint32_t _relative_save_offset;
3195                                 _relative_save_offset = ndr->offset;
3196                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3197                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3198                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3199                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3200                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3201                                 ndr->offset = _relative_save_offset;
3202                         }
3203                         ndr->flags = _flags_save_string;
3204                 }
3205                 {
3206                         uint32_t _flags_save_string = ndr->flags;
3207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3208                         if (r->server_name) {
3209                                 uint32_t _relative_save_offset;
3210                                 _relative_save_offset = ndr->offset;
3211                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3212                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3213                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3214                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3215                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3216                                 ndr->offset = _relative_save_offset;
3217                         }
3218                         ndr->flags = _flags_save_string;
3219                 }
3220                 {
3221                         uint32_t _flags_save_string = ndr->flags;
3222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3223                         if (r->user_name) {
3224                                 uint32_t _relative_save_offset;
3225                                 _relative_save_offset = ndr->offset;
3226                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3227                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3228                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3229                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3230                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3231                                 ndr->offset = _relative_save_offset;
3232                         }
3233                         ndr->flags = _flags_save_string;
3234                 }
3235                 {
3236                         uint32_t _flags_save_string = ndr->flags;
3237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3238                         if (r->document_name) {
3239                                 uint32_t _relative_save_offset;
3240                                 _relative_save_offset = ndr->offset;
3241                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3242                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3243                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3244                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3245                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3246                                 ndr->offset = _relative_save_offset;
3247                         }
3248                         ndr->flags = _flags_save_string;
3249                 }
3250                 {
3251                         uint32_t _flags_save_string = ndr->flags;
3252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3253                         if (r->data_type) {
3254                                 uint32_t _relative_save_offset;
3255                                 _relative_save_offset = ndr->offset;
3256                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3257                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3258                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3259                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3260                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3261                                 ndr->offset = _relative_save_offset;
3262                         }
3263                         ndr->flags = _flags_save_string;
3264                 }
3265                 {
3266                         uint32_t _flags_save_string = ndr->flags;
3267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3268                         if (r->text_status) {
3269                                 uint32_t _relative_save_offset;
3270                                 _relative_save_offset = ndr->offset;
3271                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3272                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3273                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3274                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3275                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3276                                 ndr->offset = _relative_save_offset;
3277                         }
3278                         ndr->flags = _flags_save_string;
3279                 }
3280         }
3281         return NDR_ERR_SUCCESS;
3282 }
3283
3284 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3285 {
3286         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3287         ndr->depth++;
3288         ndr_print_uint32(ndr, "job_id", r->job_id);
3289         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3290         ndr->depth++;
3291         if (r->printer_name) {
3292                 ndr_print_string(ndr, "printer_name", r->printer_name);
3293         }
3294         ndr->depth--;
3295         ndr_print_ptr(ndr, "server_name", r->server_name);
3296         ndr->depth++;
3297         if (r->server_name) {
3298                 ndr_print_string(ndr, "server_name", r->server_name);
3299         }
3300         ndr->depth--;
3301         ndr_print_ptr(ndr, "user_name", r->user_name);
3302         ndr->depth++;
3303         if (r->user_name) {
3304                 ndr_print_string(ndr, "user_name", r->user_name);
3305         }
3306         ndr->depth--;
3307         ndr_print_ptr(ndr, "document_name", r->document_name);
3308         ndr->depth++;
3309         if (r->document_name) {
3310                 ndr_print_string(ndr, "document_name", r->document_name);
3311         }
3312         ndr->depth--;
3313         ndr_print_ptr(ndr, "data_type", r->data_type);
3314         ndr->depth++;
3315         if (r->data_type) {
3316                 ndr_print_string(ndr, "data_type", r->data_type);
3317         }
3318         ndr->depth--;
3319         ndr_print_ptr(ndr, "text_status", r->text_status);
3320         ndr->depth++;
3321         if (r->text_status) {
3322                 ndr_print_string(ndr, "text_status", r->text_status);
3323         }
3324         ndr->depth--;
3325         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3326         ndr_print_uint32(ndr, "priority", r->priority);
3327         ndr_print_uint32(ndr, "position", r->position);
3328         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3329         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3330         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3331         ndr->depth--;
3332 }
3333
3334 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3335 {
3336         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3337 }
3338
3339 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3340 {
3341         if (ndr_flags & NDR_SCALARS) {
3342                 NDR_CHECK(ndr_push_align(ndr, 5));
3343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3344                 {
3345                         uint32_t _flags_save_string = ndr->flags;
3346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3347                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
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|LIBNDR_FLAG_ALIGN2);
3353                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3354                         ndr->flags = _flags_save_string;
3355                 }
3356                 {
3357                         uint32_t _flags_save_string = ndr->flags;
3358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3359                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3360                         ndr->flags = _flags_save_string;
3361                 }
3362                 {
3363                         uint32_t _flags_save_string = ndr->flags;
3364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3365                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3366                         ndr->flags = _flags_save_string;
3367                 }
3368                 {
3369                         uint32_t _flags_save_string = ndr->flags;
3370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3371                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3372                         ndr->flags = _flags_save_string;
3373                 }
3374                 {
3375                         uint32_t _flags_save_string = ndr->flags;
3376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3377                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
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|LIBNDR_FLAG_ALIGN2);
3383                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3384                         ndr->flags = _flags_save_string;
3385                 }
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3389                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3390                         ndr->flags = _flags_save_string;
3391                 }
3392                 {
3393                         uint32_t _flags_save_string = ndr->flags;
3394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3395                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3396                         ndr->flags = _flags_save_string;
3397                 }
3398                 {
3399                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3401                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3402                         ndr->flags = _flags_save_spoolss_DeviceMode;
3403                 }
3404                 {
3405                         uint32_t _flags_save_string = ndr->flags;
3406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3407                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3408                         ndr->flags = _flags_save_string;
3409                 }
3410                 {
3411                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3413                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3414                         ndr->flags = _flags_save_spoolss_security_descriptor;
3415                 }
3416                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3423                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3426                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3427         }
3428         if (ndr_flags & NDR_BUFFERS) {
3429                 {
3430                         uint32_t _flags_save_string = ndr->flags;
3431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3432                         if (r->printer_name) {
3433                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3434                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3435                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3436                         }
3437                         ndr->flags = _flags_save_string;
3438                 }
3439                 {
3440                         uint32_t _flags_save_string = ndr->flags;
3441                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3442                         if (r->server_name) {
3443                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3444                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3445                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3446                         }
3447                         ndr->flags = _flags_save_string;
3448                 }
3449                 {
3450                         uint32_t _flags_save_string = ndr->flags;
3451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3452                         if (r->user_name) {
3453                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3454                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3455                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3456                         }
3457                         ndr->flags = _flags_save_string;
3458                 }
3459                 {
3460                         uint32_t _flags_save_string = ndr->flags;
3461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3462                         if (r->document_name) {
3463                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3464                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3465                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3466                         }
3467                         ndr->flags = _flags_save_string;
3468                 }
3469                 {
3470                         uint32_t _flags_save_string = ndr->flags;
3471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3472                         if (r->notify_name) {
3473                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
3474                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3475                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
3476                         }
3477                         ndr->flags = _flags_save_string;
3478                 }
3479                 {
3480                         uint32_t _flags_save_string = ndr->flags;
3481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3482                         if (r->data_type) {
3483                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3484                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3485                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3486                         }
3487                         ndr->flags = _flags_save_string;
3488                 }
3489                 {
3490                         uint32_t _flags_save_string = ndr->flags;
3491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3492                         if (r->print_processor) {
3493                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
3494                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3495                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
3496                         }
3497                         ndr->flags = _flags_save_string;
3498                 }
3499                 {
3500                         uint32_t _flags_save_string = ndr->flags;
3501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3502                         if (r->parameters) {
3503                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
3504                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3505                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
3506                         }
3507                         ndr->flags = _flags_save_string;
3508                 }
3509                 {
3510                         uint32_t _flags_save_string = ndr->flags;
3511                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3512                         if (r->driver_name) {
3513                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
3514                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3515                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
3516                         }
3517                         ndr->flags = _flags_save_string;
3518                 }
3519                 {
3520                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3522                         if (r->devmode) {
3523                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
3524                                 {
3525                                         struct ndr_push *_ndr_devmode;
3526                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3527                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3528                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3529                                 }
3530                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
3531                         }
3532                         ndr->flags = _flags_save_spoolss_DeviceMode;
3533                 }
3534                 {
3535                         uint32_t _flags_save_string = ndr->flags;
3536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3537                         if (r->text_status) {
3538                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3539                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3540                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3541                         }
3542                         ndr->flags = _flags_save_string;
3543                 }
3544                 {
3545                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3547                         if (r->secdesc) {
3548                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
3549                                 {
3550                                         struct ndr_push *_ndr_secdesc;
3551                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3552                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3553                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3554                                 }
3555                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
3556                         }
3557                         ndr->flags = _flags_save_spoolss_security_descriptor;
3558                 }
3559         }
3560         return NDR_ERR_SUCCESS;
3561 }
3562
3563 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3564 {
3565         uint32_t _ptr_printer_name;
3566         TALLOC_CTX *_mem_save_printer_name_0;
3567         uint32_t _ptr_server_name;
3568         TALLOC_CTX *_mem_save_server_name_0;
3569         uint32_t _ptr_user_name;
3570         TALLOC_CTX *_mem_save_user_name_0;
3571         uint32_t _ptr_document_name;
3572         TALLOC_CTX *_mem_save_document_name_0;
3573         uint32_t _ptr_notify_name;
3574         TALLOC_CTX *_mem_save_notify_name_0;
3575         uint32_t _ptr_data_type;
3576         TALLOC_CTX *_mem_save_data_type_0;
3577         uint32_t _ptr_print_processor;
3578         TALLOC_CTX *_mem_save_print_processor_0;
3579         uint32_t _ptr_parameters;
3580         TALLOC_CTX *_mem_save_parameters_0;
3581         uint32_t _ptr_driver_name;
3582         TALLOC_CTX *_mem_save_driver_name_0;
3583         uint32_t _ptr_devmode;
3584         TALLOC_CTX *_mem_save_devmode_0;
3585         uint32_t _ptr_text_status;
3586         TALLOC_CTX *_mem_save_text_status_0;
3587         uint32_t _ptr_secdesc;
3588         TALLOC_CTX *_mem_save_secdesc_0;
3589         if (ndr_flags & NDR_SCALARS) {
3590                 NDR_CHECK(ndr_pull_align(ndr, 5));
3591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3592                 {
3593                         uint32_t _flags_save_string = ndr->flags;
3594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3595                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3596                         if (_ptr_printer_name) {
3597                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3598                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3599                         } else {
3600                                 r->printer_name = NULL;
3601                         }
3602                         ndr->flags = _flags_save_string;
3603                 }
3604                 {
3605                         uint32_t _flags_save_string = ndr->flags;
3606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3607                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3608                         if (_ptr_server_name) {
3609                                 NDR_PULL_ALLOC(ndr, r->server_name);
3610                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3611                         } else {
3612                                 r->server_name = NULL;
3613                         }
3614                         ndr->flags = _flags_save_string;
3615                 }
3616                 {
3617                         uint32_t _flags_save_string = ndr->flags;
3618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3619                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3620                         if (_ptr_user_name) {
3621                                 NDR_PULL_ALLOC(ndr, r->user_name);
3622                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3623                         } else {
3624                                 r->user_name = NULL;
3625                         }
3626                         ndr->flags = _flags_save_string;
3627                 }
3628                 {
3629                         uint32_t _flags_save_string = ndr->flags;
3630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3631                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3632                         if (_ptr_document_name) {
3633                                 NDR_PULL_ALLOC(ndr, r->document_name);
3634                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3635                         } else {
3636                                 r->document_name = NULL;
3637                         }
3638                         ndr->flags = _flags_save_string;
3639                 }
3640                 {
3641                         uint32_t _flags_save_string = ndr->flags;
3642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3643                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3644                         if (_ptr_notify_name) {
3645                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3646                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3647                         } else {
3648                                 r->notify_name = NULL;
3649                         }
3650                         ndr->flags = _flags_save_string;
3651                 }
3652                 {
3653                         uint32_t _flags_save_string = ndr->flags;
3654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3655                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3656                         if (_ptr_data_type) {
3657                                 NDR_PULL_ALLOC(ndr, r->data_type);
3658                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3659                         } else {
3660                                 r->data_type = NULL;
3661                         }
3662                         ndr->flags = _flags_save_string;
3663                 }
3664                 {
3665                         uint32_t _flags_save_string = ndr->flags;
3666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3667                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3668                         if (_ptr_print_processor) {
3669                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3670                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3671                         } else {
3672                                 r->print_processor = NULL;
3673                         }
3674                         ndr->flags = _flags_save_string;
3675                 }
3676                 {
3677                         uint32_t _flags_save_string = ndr->flags;
3678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3679                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3680                         if (_ptr_parameters) {
3681                                 NDR_PULL_ALLOC(ndr, r->parameters);
3682                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3683                         } else {
3684                                 r->parameters = NULL;
3685                         }
3686                         ndr->flags = _flags_save_string;
3687                 }
3688                 {
3689                         uint32_t _flags_save_string = ndr->flags;
3690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3691                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3692                         if (_ptr_driver_name) {
3693                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3694                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3695                         } else {
3696                                 r->driver_name = NULL;
3697                         }
3698                         ndr->flags = _flags_save_string;
3699                 }
3700                 {
3701                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3703                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3704                         if (_ptr_devmode) {
3705                                 NDR_PULL_ALLOC(ndr, r->devmode);
3706                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3707                         } else {
3708                                 r->devmode = NULL;
3709                         }
3710                         ndr->flags = _flags_save_spoolss_DeviceMode;
3711                 }
3712                 {
3713                         uint32_t _flags_save_string = ndr->flags;
3714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3715                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3716                         if (_ptr_text_status) {
3717                                 NDR_PULL_ALLOC(ndr, r->text_status);
3718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3719                         } else {
3720                                 r->text_status = NULL;
3721                         }
3722                         ndr->flags = _flags_save_string;
3723                 }
3724                 {
3725                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3728                         if (_ptr_secdesc) {
3729                                 NDR_PULL_ALLOC(ndr, r->secdesc);
3730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3731                         } else {
3732                                 r->secdesc = NULL;
3733                         }
3734                         ndr->flags = _flags_save_spoolss_security_descriptor;
3735                 }
3736                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3738                 if (r->priority > 99) {
3739                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3740                 }
3741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3746                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3749                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3750         }
3751         if (ndr_flags & NDR_BUFFERS) {
3752                 {
3753                         uint32_t _flags_save_string = ndr->flags;
3754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3755                         if (r->printer_name) {
3756                                 uint32_t _relative_save_offset;
3757                                 _relative_save_offset = ndr->offset;
3758                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3759                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3760                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3761                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3762                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3763                                 ndr->offset = _relative_save_offset;
3764                         }
3765                         ndr->flags = _flags_save_string;
3766                 }
3767                 {
3768                         uint32_t _flags_save_string = ndr->flags;
3769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3770                         if (r->server_name) {
3771                                 uint32_t _relative_save_offset;
3772                                 _relative_save_offset = ndr->offset;
3773                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3774                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3775                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3776                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3777                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3778                                 ndr->offset = _relative_save_offset;
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|LIBNDR_FLAG_ALIGN2);
3785                         if (r->user_name) {
3786                                 uint32_t _relative_save_offset;
3787                                 _relative_save_offset = ndr->offset;
3788                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3789                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3790                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3791                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3792                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3793                                 ndr->offset = _relative_save_offset;
3794                         }
3795                         ndr->flags = _flags_save_string;
3796                 }
3797                 {
3798                         uint32_t _flags_save_string = ndr->flags;
3799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3800                         if (r->document_name) {
3801                                 uint32_t _relative_save_offset;
3802                                 _relative_save_offset = ndr->offset;
3803                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3804                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3805                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3806                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3807                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3808                                 ndr->offset = _relative_save_offset;
3809                         }
3810                         ndr->flags = _flags_save_string;
3811                 }
3812                 {
3813                         uint32_t _flags_save_string = ndr->flags;
3814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3815                         if (r->notify_name) {
3816                                 uint32_t _relative_save_offset;
3817                                 _relative_save_offset = ndr->offset;
3818                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3819                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3820                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3821                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3822                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3823                                 ndr->offset = _relative_save_offset;
3824                         }
3825                         ndr->flags = _flags_save_string;
3826                 }
3827                 {
3828                         uint32_t _flags_save_string = ndr->flags;
3829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3830                         if (r->data_type) {
3831                                 uint32_t _relative_save_offset;
3832                                 _relative_save_offset = ndr->offset;
3833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3834                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3835                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3838                                 ndr->offset = _relative_save_offset;
3839                         }
3840                         ndr->flags = _flags_save_string;
3841                 }
3842                 {
3843                         uint32_t _flags_save_string = ndr->flags;
3844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3845                         if (r->print_processor) {
3846                                 uint32_t _relative_save_offset;
3847                                 _relative_save_offset = ndr->offset;
3848                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3849                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3850                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3851                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3852                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3853                                 ndr->offset = _relative_save_offset;
3854                         }
3855                         ndr->flags = _flags_save_string;
3856                 }
3857                 {
3858                         uint32_t _flags_save_string = ndr->flags;
3859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3860                         if (r->parameters) {
3861                                 uint32_t _relative_save_offset;
3862                                 _relative_save_offset = ndr->offset;
3863                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3864                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3865                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3866                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3867                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3868                                 ndr->offset = _relative_save_offset;
3869                         }
3870                         ndr->flags = _flags_save_string;
3871                 }
3872                 {
3873                         uint32_t _flags_save_string = ndr->flags;
3874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3875                         if (r->driver_name) {
3876                                 uint32_t _relative_save_offset;
3877                                 _relative_save_offset = ndr->offset;
3878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3879                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3880                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3883                                 ndr->offset = _relative_save_offset;
3884                         }
3885                         ndr->flags = _flags_save_string;
3886                 }
3887                 {
3888                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3890                         if (r->devmode) {
3891                                 uint32_t _relative_save_offset;
3892                                 _relative_save_offset = ndr->offset;
3893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3894                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3895                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3896                                 {
3897                                         struct ndr_pull *_ndr_devmode;
3898                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3899                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3900                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
3901                                 }
3902                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3903                                 ndr->offset = _relative_save_offset;
3904                         }
3905                         ndr->flags = _flags_save_spoolss_DeviceMode;
3906                 }
3907                 {
3908                         uint32_t _flags_save_string = ndr->flags;
3909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3910                         if (r->text_status) {
3911                                 uint32_t _relative_save_offset;
3912                                 _relative_save_offset = ndr->offset;
3913                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3914                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3915                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3916                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3917                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3918                                 ndr->offset = _relative_save_offset;
3919                         }
3920                         ndr->flags = _flags_save_string;
3921                 }
3922                 {
3923                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3925                         if (r->secdesc) {
3926                                 uint32_t _relative_save_offset;
3927                                 _relative_save_offset = ndr->offset;
3928                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3929                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3930                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3931                                 {
3932                                         struct ndr_pull *_ndr_secdesc;
3933                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3934                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3935                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3936                                 }
3937                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3938                                 ndr->offset = _relative_save_offset;
3939                         }
3940                         ndr->flags = _flags_save_spoolss_security_descriptor;
3941                 }
3942         }
3943         return NDR_ERR_SUCCESS;
3944 }
3945
3946 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3947 {
3948         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3949         ndr->depth++;
3950         ndr_print_uint32(ndr, "job_id", r->job_id);
3951         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3952         ndr->depth++;
3953         if (r->printer_name) {
3954                 ndr_print_string(ndr, "printer_name", r->printer_name);
3955         }
3956         ndr->depth--;
3957         ndr_print_ptr(ndr, "server_name", r->server_name);
3958         ndr->depth++;
3959         if (r->server_name) {
3960                 ndr_print_string(ndr, "server_name", r->server_name);
3961         }
3962         ndr->depth--;
3963         ndr_print_ptr(ndr, "user_name", r->user_name);
3964         ndr->depth++;
3965         if (r->user_name) {
3966                 ndr_print_string(ndr, "user_name", r->user_name);
3967         }
3968         ndr->depth--;
3969         ndr_print_ptr(ndr, "document_name", r->document_name);
3970         ndr->depth++;
3971         if (r->document_name) {
3972                 ndr_print_string(ndr, "document_name", r->document_name);
3973         }
3974         ndr->depth--;
3975         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3976         ndr->depth++;
3977         if (r->notify_name) {
3978                 ndr_print_string(ndr, "notify_name", r->notify_name);
3979         }
3980         ndr->depth--;
3981         ndr_print_ptr(ndr, "data_type", r->data_type);
3982         ndr->depth++;
3983         if (r->data_type) {
3984                 ndr_print_string(ndr, "data_type", r->data_type);
3985         }
3986         ndr->depth--;
3987         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3988         ndr->depth++;
3989         if (r->print_processor) {
3990                 ndr_print_string(ndr, "print_processor", r->print_processor);
3991         }
3992         ndr->depth--;
3993         ndr_print_ptr(ndr, "parameters", r->parameters);
3994         ndr->depth++;
3995         if (r->parameters) {
3996                 ndr_print_string(ndr, "parameters", r->parameters);
3997         }
3998         ndr->depth--;
3999         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4000         ndr->depth++;
4001         if (r->driver_name) {
4002                 ndr_print_string(ndr, "driver_name", r->driver_name);
4003         }
4004         ndr->depth--;
4005         ndr_print_ptr(ndr, "devmode", r->devmode);
4006         ndr->depth++;
4007         if (r->devmode) {
4008                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4009         }
4010         ndr->depth--;
4011         ndr_print_ptr(ndr, "text_status", r->text_status);
4012         ndr->depth++;
4013         if (r->text_status) {
4014                 ndr_print_string(ndr, "text_status", r->text_status);
4015         }
4016         ndr->depth--;
4017         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4018         ndr->depth++;
4019         if (r->secdesc) {
4020                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4021         }
4022         ndr->depth--;
4023         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4024         ndr_print_uint32(ndr, "priority", r->priority);
4025         ndr_print_uint32(ndr, "position", r->position);
4026         ndr_print_uint32(ndr, "start_time", r->start_time);
4027         ndr_print_uint32(ndr, "until_time", r->until_time);
4028         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4029         ndr_print_uint32(ndr, "size", r->size);
4030         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4031         ndr_print_uint32(ndr, "time", r->time);
4032         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4033         ndr->depth--;
4034 }
4035
4036 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4037 {
4038         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4039 }
4040
4041 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4042 {
4043         if (ndr_flags & NDR_SCALARS) {
4044                 NDR_CHECK(ndr_push_align(ndr, 4));
4045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4048                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4049         }
4050         if (ndr_flags & NDR_BUFFERS) {
4051         }
4052         return NDR_ERR_SUCCESS;
4053 }
4054
4055 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4056 {
4057         if (ndr_flags & NDR_SCALARS) {
4058                 NDR_CHECK(ndr_pull_align(ndr, 4));
4059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4062                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4063         }
4064         if (ndr_flags & NDR_BUFFERS) {
4065         }
4066         return NDR_ERR_SUCCESS;
4067 }
4068
4069 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4070 {
4071         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4072         ndr->depth++;
4073         ndr_print_uint32(ndr, "job_id", r->job_id);
4074         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4075         ndr_print_uint32(ndr, "reserved", r->reserved);
4076         ndr->depth--;
4077 }
4078
4079 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4080 {
4081         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4082 }
4083
4084 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4085 {
4086         if (ndr_flags & NDR_SCALARS) {
4087                 NDR_CHECK(ndr_push_align(ndr, 5));
4088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4089                 {
4090                         uint32_t _flags_save_string = ndr->flags;
4091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4092                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4093                         ndr->flags = _flags_save_string;
4094                 }
4095                 {
4096                         uint32_t _flags_save_string = ndr->flags;
4097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4098                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4099                         ndr->flags = _flags_save_string;
4100                 }
4101                 {
4102                         uint32_t _flags_save_string = ndr->flags;
4103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4104                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4105                         ndr->flags = _flags_save_string;
4106                 }
4107                 {
4108                         uint32_t _flags_save_string = ndr->flags;
4109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4110                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4111                         ndr->flags = _flags_save_string;
4112                 }
4113                 {
4114                         uint32_t _flags_save_string = ndr->flags;
4115                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4116                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4117                         ndr->flags = _flags_save_string;
4118                 }
4119                 {
4120                         uint32_t _flags_save_string = ndr->flags;
4121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4122                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4123                         ndr->flags = _flags_save_string;
4124                 }
4125                 {
4126                         uint32_t _flags_save_string = ndr->flags;
4127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4128                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4129                         ndr->flags = _flags_save_string;
4130                 }
4131                 {
4132                         uint32_t _flags_save_string = ndr->flags;
4133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4134                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4135                         ndr->flags = _flags_save_string;
4136                 }
4137                 {
4138                         uint32_t _flags_save_string = ndr->flags;
4139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4140                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4141                         ndr->flags = _flags_save_string;
4142                 }
4143                 {
4144                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4145                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4146                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4147                         ndr->flags = _flags_save_spoolss_DeviceMode;
4148                 }
4149                 {
4150                         uint32_t _flags_save_string = ndr->flags;
4151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4152                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4153                         ndr->flags = _flags_save_string;
4154                 }
4155                 {
4156                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4158                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4159                         ndr->flags = _flags_save_spoolss_security_descriptor;
4160                 }
4161                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4168                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4172                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4173         }
4174         if (ndr_flags & NDR_BUFFERS) {
4175                 {
4176                         uint32_t _flags_save_string = ndr->flags;
4177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4178                         if (r->printer_name) {
4179                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
4180                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4181                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
4182                         }
4183                         ndr->flags = _flags_save_string;
4184                 }
4185                 {
4186                         uint32_t _flags_save_string = ndr->flags;
4187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4188                         if (r->server_name) {
4189                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
4190                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4191                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
4192                         }
4193                         ndr->flags = _flags_save_string;
4194                 }
4195                 {
4196                         uint32_t _flags_save_string = ndr->flags;
4197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4198                         if (r->user_name) {
4199                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
4200                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4201                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
4202                         }
4203                         ndr->flags = _flags_save_string;
4204                 }
4205                 {
4206                         uint32_t _flags_save_string = ndr->flags;
4207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4208                         if (r->document_name) {
4209                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
4210                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4211                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
4212                         }
4213                         ndr->flags = _flags_save_string;
4214                 }
4215                 {
4216                         uint32_t _flags_save_string = ndr->flags;
4217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4218                         if (r->notify_name) {
4219                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
4220                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4221                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
4222                         }
4223                         ndr->flags = _flags_save_string;
4224                 }
4225                 {
4226                         uint32_t _flags_save_string = ndr->flags;
4227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4228                         if (r->data_type) {
4229                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
4230                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4231                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
4232                         }
4233                         ndr->flags = _flags_save_string;
4234                 }
4235                 {
4236                         uint32_t _flags_save_string = ndr->flags;
4237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4238                         if (r->print_processor) {
4239                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
4240                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4241                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
4242                         }
4243                         ndr->flags = _flags_save_string;
4244                 }
4245                 {
4246                         uint32_t _flags_save_string = ndr->flags;
4247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4248                         if (r->parameters) {
4249                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
4250                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4251                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
4252                         }
4253                         ndr->flags = _flags_save_string;
4254                 }
4255                 {
4256                         uint32_t _flags_save_string = ndr->flags;
4257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4258                         if (r->driver_name) {
4259                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
4260                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4261                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
4262                         }
4263                         ndr->flags = _flags_save_string;
4264                 }
4265                 {
4266                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4268                         if (r->devmode) {
4269                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
4270                                 {
4271                                         struct ndr_push *_ndr_devmode;
4272                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4273                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4274                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
4275                                 }
4276                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
4277                         }
4278                         ndr->flags = _flags_save_spoolss_DeviceMode;
4279                 }
4280                 {
4281                         uint32_t _flags_save_string = ndr->flags;
4282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4283                         if (r->text_status) {
4284                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
4285                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4286                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
4287                         }
4288                         ndr->flags = _flags_save_string;
4289                 }
4290                 {
4291                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4293                         if (r->secdesc) {
4294                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
4295                                 {
4296                                         struct ndr_push *_ndr_secdesc;
4297                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4298                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4299                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4300                                 }
4301                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
4302                         }
4303                         ndr->flags = _flags_save_spoolss_security_descriptor;
4304                 }
4305         }
4306         return NDR_ERR_SUCCESS;
4307 }
4308
4309 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4310 {
4311         uint32_t _ptr_printer_name;
4312         TALLOC_CTX *_mem_save_printer_name_0;
4313         uint32_t _ptr_server_name;
4314         TALLOC_CTX *_mem_save_server_name_0;
4315         uint32_t _ptr_user_name;
4316         TALLOC_CTX *_mem_save_user_name_0;
4317         uint32_t _ptr_document_name;
4318         TALLOC_CTX *_mem_save_document_name_0;
4319         uint32_t _ptr_notify_name;
4320         TALLOC_CTX *_mem_save_notify_name_0;
4321         uint32_t _ptr_data_type;
4322         TALLOC_CTX *_mem_save_data_type_0;
4323         uint32_t _ptr_print_processor;
4324         TALLOC_CTX *_mem_save_print_processor_0;
4325         uint32_t _ptr_parameters;
4326         TALLOC_CTX *_mem_save_parameters_0;
4327         uint32_t _ptr_driver_name;
4328         TALLOC_CTX *_mem_save_driver_name_0;
4329         uint32_t _ptr_devmode;
4330         TALLOC_CTX *_mem_save_devmode_0;
4331         uint32_t _ptr_text_status;
4332         TALLOC_CTX *_mem_save_text_status_0;
4333         uint32_t _ptr_secdesc;
4334         TALLOC_CTX *_mem_save_secdesc_0;
4335         if (ndr_flags & NDR_SCALARS) {
4336                 NDR_CHECK(ndr_pull_align(ndr, 5));
4337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4338                 {
4339                         uint32_t _flags_save_string = ndr->flags;
4340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4342                         if (_ptr_printer_name) {
4343                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4345                         } else {
4346                                 r->printer_name = NULL;
4347                         }
4348                         ndr->flags = _flags_save_string;
4349                 }
4350                 {
4351                         uint32_t _flags_save_string = ndr->flags;
4352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4354                         if (_ptr_server_name) {
4355                                 NDR_PULL_ALLOC(ndr, r->server_name);
4356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4357                         } else {
4358                                 r->server_name = NULL;
4359                         }
4360                         ndr->flags = _flags_save_string;
4361                 }
4362                 {
4363                         uint32_t _flags_save_string = ndr->flags;
4364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4366                         if (_ptr_user_name) {
4367                                 NDR_PULL_ALLOC(ndr, r->user_name);
4368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4369                         } else {
4370                                 r->user_name = NULL;
4371                         }
4372                         ndr->flags = _flags_save_string;
4373                 }
4374                 {
4375                         uint32_t _flags_save_string = ndr->flags;
4376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4377                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4378                         if (_ptr_document_name) {
4379                                 NDR_PULL_ALLOC(ndr, r->document_name);
4380                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4381                         } else {
4382                                 r->document_name = NULL;
4383                         }
4384                         ndr->flags = _flags_save_string;
4385                 }
4386                 {
4387                         uint32_t _flags_save_string = ndr->flags;
4388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4389                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4390                         if (_ptr_notify_name) {
4391                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4392                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4393                         } else {
4394                                 r->notify_name = NULL;
4395                         }
4396                         ndr->flags = _flags_save_string;
4397                 }
4398                 {
4399                         uint32_t _flags_save_string = ndr->flags;
4400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4401                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4402                         if (_ptr_data_type) {
4403                                 NDR_PULL_ALLOC(ndr, r->data_type);
4404                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4405                         } else {
4406                                 r->data_type = NULL;
4407                         }
4408                         ndr->flags = _flags_save_string;
4409                 }
4410                 {
4411                         uint32_t _flags_save_string = ndr->flags;
4412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4413                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4414                         if (_ptr_print_processor) {
4415                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4416                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4417                         } else {
4418                                 r->print_processor = NULL;
4419                         }
4420                         ndr->flags = _flags_save_string;
4421                 }
4422                 {
4423                         uint32_t _flags_save_string = ndr->flags;
4424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4425                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4426                         if (_ptr_parameters) {
4427                                 NDR_PULL_ALLOC(ndr, r->parameters);
4428                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4429                         } else {
4430                                 r->parameters = NULL;
4431                         }
4432                         ndr->flags = _flags_save_string;
4433                 }
4434                 {
4435                         uint32_t _flags_save_string = ndr->flags;
4436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4437                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4438                         if (_ptr_driver_name) {
4439                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4440                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4441                         } else {
4442                                 r->driver_name = NULL;
4443                         }
4444                         ndr->flags = _flags_save_string;
4445                 }
4446                 {
4447                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4449                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4450                         if (_ptr_devmode) {
4451                                 NDR_PULL_ALLOC(ndr, r->devmode);
4452                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4453                         } else {
4454                                 r->devmode = NULL;
4455                         }
4456                         ndr->flags = _flags_save_spoolss_DeviceMode;
4457                 }
4458                 {
4459                         uint32_t _flags_save_string = ndr->flags;
4460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4461                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4462                         if (_ptr_text_status) {
4463                                 NDR_PULL_ALLOC(ndr, r->text_status);
4464                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4465                         } else {
4466                                 r->text_status = NULL;
4467                         }
4468                         ndr->flags = _flags_save_string;
4469                 }
4470                 {
4471                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4473                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4474                         if (_ptr_secdesc) {
4475                                 NDR_PULL_ALLOC(ndr, r->secdesc);
4476                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4477                         } else {
4478                                 r->secdesc = NULL;
4479                         }
4480                         ndr->flags = _flags_save_spoolss_security_descriptor;
4481                 }
4482                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4484                 if (r->priority > 99) {
4485                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4486                 }
4487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4492                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4496                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4497         }
4498         if (ndr_flags & NDR_BUFFERS) {
4499                 {
4500                         uint32_t _flags_save_string = ndr->flags;
4501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4502                         if (r->printer_name) {
4503                                 uint32_t _relative_save_offset;
4504                                 _relative_save_offset = ndr->offset;
4505                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4506                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4507                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4508                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4509                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4510                                 ndr->offset = _relative_save_offset;
4511                         }
4512                         ndr->flags = _flags_save_string;
4513                 }
4514                 {
4515                         uint32_t _flags_save_string = ndr->flags;
4516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4517                         if (r->server_name) {
4518                                 uint32_t _relative_save_offset;
4519                                 _relative_save_offset = ndr->offset;
4520                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4521                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4522                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4523                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4524                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4525                                 ndr->offset = _relative_save_offset;
4526                         }
4527                         ndr->flags = _flags_save_string;
4528                 }
4529                 {
4530                         uint32_t _flags_save_string = ndr->flags;
4531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4532                         if (r->user_name) {
4533                                 uint32_t _relative_save_offset;
4534                                 _relative_save_offset = ndr->offset;
4535                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4536                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4537                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4538                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4539                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4540                                 ndr->offset = _relative_save_offset;
4541                         }
4542                         ndr->flags = _flags_save_string;
4543                 }
4544                 {
4545                         uint32_t _flags_save_string = ndr->flags;
4546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4547                         if (r->document_name) {
4548                                 uint32_t _relative_save_offset;
4549                                 _relative_save_offset = ndr->offset;
4550                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4551                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4552                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4553                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4554                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4555                                 ndr->offset = _relative_save_offset;
4556                         }
4557                         ndr->flags = _flags_save_string;
4558                 }
4559                 {
4560                         uint32_t _flags_save_string = ndr->flags;
4561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4562                         if (r->notify_name) {
4563                                 uint32_t _relative_save_offset;
4564                                 _relative_save_offset = ndr->offset;
4565                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4566                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4567                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4568                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4569                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4570                                 ndr->offset = _relative_save_offset;
4571                         }
4572                         ndr->flags = _flags_save_string;
4573                 }
4574                 {
4575                         uint32_t _flags_save_string = ndr->flags;
4576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4577                         if (r->data_type) {
4578                                 uint32_t _relative_save_offset;
4579                                 _relative_save_offset = ndr->offset;
4580                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4581                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4582                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4583                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4584                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4585                                 ndr->offset = _relative_save_offset;
4586                         }
4587                         ndr->flags = _flags_save_string;
4588                 }
4589                 {
4590                         uint32_t _flags_save_string = ndr->flags;
4591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4592                         if (r->print_processor) {
4593                                 uint32_t _relative_save_offset;
4594                                 _relative_save_offset = ndr->offset;
4595                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4596                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4597                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4598                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4599                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4600                                 ndr->offset = _relative_save_offset;
4601                         }
4602                         ndr->flags = _flags_save_string;
4603                 }
4604                 {
4605                         uint32_t _flags_save_string = ndr->flags;
4606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4607                         if (r->parameters) {
4608                                 uint32_t _relative_save_offset;
4609                                 _relative_save_offset = ndr->offset;
4610                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4611                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4612                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4613                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4614                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4615                                 ndr->offset = _relative_save_offset;
4616                         }
4617                         ndr->flags = _flags_save_string;
4618                 }
4619                 {
4620                         uint32_t _flags_save_string = ndr->flags;
4621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4622                         if (r->driver_name) {
4623                                 uint32_t _relative_save_offset;
4624                                 _relative_save_offset = ndr->offset;
4625                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4626                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4627                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4628                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4629                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4630                                 ndr->offset = _relative_save_offset;
4631                         }
4632                         ndr->flags = _flags_save_string;
4633                 }
4634                 {
4635                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4637                         if (r->devmode) {
4638                                 uint32_t _relative_save_offset;
4639                                 _relative_save_offset = ndr->offset;
4640                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4641                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4642                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4643                                 {
4644                                         struct ndr_pull *_ndr_devmode;
4645                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4646                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4647                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
4648                                 }
4649                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4650                                 ndr->offset = _relative_save_offset;
4651                         }
4652                         ndr->flags = _flags_save_spoolss_DeviceMode;
4653                 }
4654                 {
4655                         uint32_t _flags_save_string = ndr->flags;
4656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4657                         if (r->text_status) {
4658                                 uint32_t _relative_save_offset;
4659                                 _relative_save_offset = ndr->offset;
4660                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4661                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4662                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4663                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4664                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4665                                 ndr->offset = _relative_save_offset;
4666                         }
4667                         ndr->flags = _flags_save_string;
4668                 }
4669                 {
4670                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4672                         if (r->secdesc) {
4673                                 uint32_t _relative_save_offset;
4674                                 _relative_save_offset = ndr->offset;
4675                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4676                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4677                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4678                                 {
4679                                         struct ndr_pull *_ndr_secdesc;
4680                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4681                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4682                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4683                                 }
4684                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4685                                 ndr->offset = _relative_save_offset;
4686                         }
4687                         ndr->flags = _flags_save_spoolss_security_descriptor;
4688                 }
4689         }
4690         return NDR_ERR_SUCCESS;
4691 }
4692
4693 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4694 {
4695         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4696         ndr->depth++;
4697         ndr_print_uint32(ndr, "job_id", r->job_id);
4698         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4699         ndr->depth++;
4700         if (r->printer_name) {
4701                 ndr_print_string(ndr, "printer_name", r->printer_name);
4702         }
4703         ndr->depth--;
4704         ndr_print_ptr(ndr, "server_name", r->server_name);
4705         ndr->depth++;
4706         if (r->server_name) {
4707                 ndr_print_string(ndr, "server_name", r->server_name);
4708         }
4709         ndr->depth--;
4710         ndr_print_ptr(ndr, "user_name", r->user_name);
4711         ndr->depth++;
4712         if (r->user_name) {
4713                 ndr_print_string(ndr, "user_name", r->user_name);
4714         }
4715         ndr->depth--;
4716         ndr_print_ptr(ndr, "document_name", r->document_name);
4717         ndr->depth++;
4718         if (r->document_name) {
4719                 ndr_print_string(ndr, "document_name", r->document_name);
4720         }
4721         ndr->depth--;
4722         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4723         ndr->depth++;
4724         if (r->notify_name) {
4725                 ndr_print_string(ndr, "notify_name", r->notify_name);
4726         }
4727         ndr->depth--;
4728         ndr_print_ptr(ndr, "data_type", r->data_type);
4729         ndr->depth++;
4730         if (r->data_type) {
4731                 ndr_print_string(ndr, "data_type", r->data_type);
4732         }
4733         ndr->depth--;
4734         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4735         ndr->depth++;
4736         if (r->print_processor) {
4737                 ndr_print_string(ndr, "print_processor", r->print_processor);
4738         }
4739         ndr->depth--;
4740         ndr_print_ptr(ndr, "parameters", r->parameters);
4741         ndr->depth++;
4742         if (r->parameters) {
4743                 ndr_print_string(ndr, "parameters", r->parameters);
4744         }
4745         ndr->depth--;
4746         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4747         ndr->depth++;
4748         if (r->driver_name) {
4749                 ndr_print_string(ndr, "driver_name", r->driver_name);
4750         }
4751         ndr->depth--;
4752         ndr_print_ptr(ndr, "devmode", r->devmode);
4753         ndr->depth++;
4754         if (r->devmode) {
4755                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4756         }
4757         ndr->depth--;
4758         ndr_print_ptr(ndr, "text_status", r->text_status);
4759         ndr->depth++;
4760         if (r->text_status) {
4761                 ndr_print_string(ndr, "text_status", r->text_status);
4762         }
4763         ndr->depth--;
4764         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4765         ndr->depth++;
4766         if (r->secdesc) {
4767                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4768         }
4769         ndr->depth--;
4770         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4771         ndr_print_uint32(ndr, "priority", r->priority);
4772         ndr_print_uint32(ndr, "position", r->position);
4773         ndr_print_uint32(ndr, "start_time", r->start_time);
4774         ndr_print_uint32(ndr, "until_time", r->until_time);
4775         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4776         ndr_print_uint32(ndr, "size", r->size);
4777         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4778         ndr_print_uint32(ndr, "time", r->time);
4779         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4780         ndr_print_uint32(ndr, "size_high", r->size_high);
4781         ndr->depth--;
4782 }
4783
4784 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4785 {
4786         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4787 }
4788
4789 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4790 {
4791         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4792         {
4793                 uint32_t _flags_save_UNION = ndr->flags;
4794                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4795                 if (ndr_flags & NDR_SCALARS) {
4796                         int level = ndr_push_get_switch_value(ndr, r);
4797                         NDR_CHECK(ndr_push_union_align(ndr, 5));
4798                         switch (level) {
4799                                 case 1: {
4800                                         NDR_CHECK(ndr_push_align(ndr, 5));
4801                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4802                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4803                                 break; }
4804
4805                                 case 2: {
4806                                         NDR_CHECK(ndr_push_align(ndr, 5));
4807                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4808                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4809                                 break; }
4810
4811                                 case 3: {
4812                                         NDR_CHECK(ndr_push_align(ndr, 4));
4813                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4814                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4815                                 break; }
4816
4817                                 case 4: {
4818                                         NDR_CHECK(ndr_push_align(ndr, 5));
4819                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4820                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4821                                 break; }
4822
4823                                 default: {
4824                                 break; }
4825
4826                         }
4827                 }
4828                 if (ndr_flags & NDR_BUFFERS) {
4829                         int level = ndr_push_get_switch_value(ndr, r);
4830                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4831                         switch (level) {
4832                                 case 1:
4833                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4834                                 break;
4835
4836                                 case 2:
4837                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4838                                 break;
4839
4840                                 case 3:
4841                                 break;
4842
4843                                 case 4:
4844                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4845                                 break;
4846
4847                                 default:
4848                                 break;
4849
4850                         }
4851                 }
4852                 ndr->flags = _flags_save_UNION;
4853         }
4854         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4855         return NDR_ERR_SUCCESS;
4856 }
4857
4858 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4859 {
4860         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4861         int level;
4862         {
4863                 uint32_t _flags_save_UNION = ndr->flags;
4864                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4865                 level = ndr_pull_get_switch_value(ndr, r);
4866                 if (ndr_flags & NDR_SCALARS) {
4867                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
4868                         switch (level) {
4869                                 case 1: {
4870                                         NDR_CHECK(ndr_pull_align(ndr, 5));
4871                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4872                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4873                                 break; }
4874
4875                                 case 2: {
4876                                         NDR_CHECK(ndr_pull_align(ndr, 5));
4877                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4878                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4879                                 break; }
4880
4881                                 case 3: {
4882                                         NDR_CHECK(ndr_pull_align(ndr, 4));
4883                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4884                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4885                                 break; }
4886
4887                                 case 4: {
4888                                         NDR_CHECK(ndr_pull_align(ndr, 5));
4889                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4890                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4891                                 break; }
4892
4893                                 default: {
4894                                 break; }
4895
4896                         }
4897                 }
4898                 if (ndr_flags & NDR_BUFFERS) {
4899                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4900                         switch (level) {
4901                                 case 1:
4902                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4903                                 break;
4904
4905                                 case 2:
4906                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4907                                 break;
4908
4909                                 case 3:
4910                                 break;
4911
4912                                 case 4:
4913                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4914                                 break;
4915
4916                                 default:
4917                                 break;
4918
4919                         }
4920                 }
4921                 ndr->flags = _flags_save_UNION;
4922         }
4923         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4924         return NDR_ERR_SUCCESS;
4925 }
4926
4927 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4928 {
4929         int level;
4930         {
4931                 uint32_t _flags_save_UNION = ndr->flags;
4932                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4933                 level = ndr_print_get_switch_value(ndr, r);
4934                 ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4935                 switch (level) {
4936                         case 1:
4937                                 ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4938                         break;
4939
4940                         case 2:
4941                                 ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4942                         break;
4943
4944                         case 3:
4945                                 ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4946                         break;
4947
4948                         case 4:
4949                                 ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4950                         break;
4951
4952                         default:
4953                         break;
4954
4955                 }
4956                 ndr->flags = _flags_save_UNION;
4957         }
4958 }
4959
4960 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4961 {
4962         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
4963         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4964 }
4965
4966 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4967 {
4968         if (ndr_flags & NDR_SCALARS) {
4969                 NDR_CHECK(ndr_push_align(ndr, 5));
4970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4971                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4972                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4975                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4977                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4982                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4983                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4984         }
4985         if (ndr_flags & NDR_BUFFERS) {
4986                 if (r->printer_name) {
4987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4988                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4990                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4991                 }
4992                 if (r->server_name) {
4993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4996                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4997                 }
4998                 if (r->user_name) {
4999                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5000                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5002                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5003                 }
5004                 if (r->document_name) {
5005                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5006                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5007                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5008                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5009                 }
5010                 if (r->data_type) {
5011                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5012                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5013                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5014                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5015                 }
5016                 if (r->text_status) {
5017                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5018                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5019                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5020                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5021                 }
5022         }
5023         return NDR_ERR_SUCCESS;
5024 }
5025
5026 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5027 {
5028         uint32_t _ptr_printer_name;
5029         uint32_t size_printer_name_1 = 0;
5030         uint32_t length_printer_name_1 = 0;
5031         TALLOC_CTX *_mem_save_printer_name_0;
5032         uint32_t _ptr_server_name;
5033         uint32_t size_server_name_1 = 0;
5034         uint32_t length_server_name_1 = 0;
5035         TALLOC_CTX *_mem_save_server_name_0;
5036         uint32_t _ptr_user_name;
5037         uint32_t size_user_name_1 = 0;
5038         uint32_t length_user_name_1 = 0;
5039         TALLOC_CTX *_mem_save_user_name_0;
5040         uint32_t _ptr_document_name;
5041         uint32_t size_document_name_1 = 0;
5042         uint32_t length_document_name_1 = 0;
5043         TALLOC_CTX *_mem_save_document_name_0;
5044         uint32_t _ptr_data_type;
5045         uint32_t size_data_type_1 = 0;
5046         uint32_t length_data_type_1 = 0;
5047         TALLOC_CTX *_mem_save_data_type_0;
5048         uint32_t _ptr_text_status;
5049         uint32_t size_text_status_1 = 0;
5050         uint32_t length_text_status_1 = 0;
5051         TALLOC_CTX *_mem_save_text_status_0;
5052         if (ndr_flags & NDR_SCALARS) {
5053                 NDR_CHECK(ndr_pull_align(ndr, 5));
5054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5056                 if (_ptr_printer_name) {
5057                         NDR_PULL_ALLOC(ndr, r->printer_name);
5058                 } else {
5059                         r->printer_name = NULL;
5060                 }
5061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5062                 if (_ptr_server_name) {
5063                         NDR_PULL_ALLOC(ndr, r->server_name);
5064                 } else {
5065                         r->server_name = NULL;
5066                 }
5067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5068                 if (_ptr_user_name) {
5069                         NDR_PULL_ALLOC(ndr, r->user_name);
5070                 } else {
5071                         r->user_name = NULL;
5072                 }
5073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5074                 if (_ptr_document_name) {
5075                         NDR_PULL_ALLOC(ndr, r->document_name);
5076                 } else {
5077                         r->document_name = NULL;
5078                 }
5079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5080                 if (_ptr_data_type) {
5081                         NDR_PULL_ALLOC(ndr, r->data_type);
5082                 } else {
5083                         r->data_type = NULL;
5084                 }
5085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5086                 if (_ptr_text_status) {
5087                         NDR_PULL_ALLOC(ndr, r->text_status);
5088                 } else {
5089                         r->text_status = NULL;
5090                 }
5091                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5093                 if (r->priority > 99) {
5094                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5095                 }
5096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5099                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5100                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5101         }
5102         if (ndr_flags & NDR_BUFFERS) {
5103                 if (r->printer_name) {
5104                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5105                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5108                         size_printer_name_1 = ndr_get_array_size(ndr, &r->printer_name);
5109                         length_printer_name_1 = ndr_get_array_length(ndr, &r->printer_name);
5110                         if (length_printer_name_1 > size_printer_name_1) {
5111                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printer_name_1, length_printer_name_1);
5112                         }
5113                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printer_name_1, sizeof(uint16_t)));
5114                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, length_printer_name_1, sizeof(uint16_t), CH_UTF16));
5115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5116                 }
5117                 if (r->server_name) {
5118                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5119                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5121                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5122                         size_server_name_1 = ndr_get_array_size(ndr, &r->server_name);
5123                         length_server_name_1 = ndr_get_array_length(ndr, &r->server_name);
5124                         if (length_server_name_1 > size_server_name_1) {
5125                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_name_1, length_server_name_1);
5126                         }
5127                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_name_1, sizeof(uint16_t)));
5128                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, length_server_name_1, sizeof(uint16_t), CH_UTF16));
5129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5130                 }
5131                 if (r->user_name) {
5132                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5133                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5134                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5135                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5136                         size_user_name_1 = ndr_get_array_size(ndr, &r->user_name);
5137                         length_user_name_1 = ndr_get_array_length(ndr, &r->user_name);
5138                         if (length_user_name_1 > size_user_name_1) {
5139                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_name_1, length_user_name_1);
5140                         }
5141                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_name_1, sizeof(uint16_t)));
5142                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, length_user_name_1, sizeof(uint16_t), CH_UTF16));
5143                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5144                 }
5145                 if (r->document_name) {
5146                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5147                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5148                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5149                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5150                         size_document_name_1 = ndr_get_array_size(ndr, &r->document_name);
5151                         length_document_name_1 = ndr_get_array_length(ndr, &r->document_name);
5152                         if (length_document_name_1 > size_document_name_1) {
5153                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_document_name_1, length_document_name_1);
5154                         }
5155                         NDR_CHECK(ndr_check_string_terminator(ndr, length_document_name_1, sizeof(uint16_t)));
5156                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, length_document_name_1, sizeof(uint16_t), CH_UTF16));
5157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5158                 }
5159                 if (r->data_type) {
5160                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5161                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5164                         size_data_type_1 = ndr_get_array_size(ndr, &r->data_type);
5165                         length_data_type_1 = ndr_get_array_length(ndr, &r->data_type);
5166                         if (length_data_type_1 > size_data_type_1) {
5167                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_type_1, length_data_type_1);
5168                         }
5169                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_type_1, sizeof(uint16_t)));
5170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, length_data_type_1, sizeof(uint16_t), CH_UTF16));
5171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5172                 }
5173                 if (r->text_status) {
5174                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5175                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5178                         size_text_status_1 = ndr_get_array_size(ndr, &r->text_status);
5179                         length_text_status_1 = ndr_get_array_length(ndr, &r->text_status);
5180                         if (length_text_status_1 > size_text_status_1) {
5181                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_text_status_1, length_text_status_1);
5182                         }
5183                         NDR_CHECK(ndr_check_string_terminator(ndr, length_text_status_1, sizeof(uint16_t)));
5184                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, length_text_status_1, sizeof(uint16_t), CH_UTF16));
5185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5186                 }
5187         }
5188         return NDR_ERR_SUCCESS;
5189 }
5190
5191 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5192 {
5193         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5194         ndr->depth++;
5195         ndr_print_uint32(ndr, "job_id", r->job_id);
5196         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5197         ndr->depth++;
5198         if (r->printer_name) {
5199                 ndr_print_string(ndr, "printer_name", r->printer_name);
5200         }
5201         ndr->depth--;
5202         ndr_print_ptr(ndr, "server_name", r->server_name);
5203         ndr->depth++;
5204         if (r->server_name) {
5205                 ndr_print_string(ndr, "server_name", r->server_name);
5206         }
5207         ndr->depth--;
5208         ndr_print_ptr(ndr, "user_name", r->user_name);
5209         ndr->depth++;
5210         if (r->user_name) {
5211                 ndr_print_string(ndr, "user_name", r->user_name);
5212         }
5213         ndr->depth--;
5214         ndr_print_ptr(ndr, "document_name", r->document_name);
5215         ndr->depth++;
5216         if (r->document_name) {
5217                 ndr_print_string(ndr, "document_name", r->document_name);
5218         }
5219         ndr->depth--;
5220         ndr_print_ptr(ndr, "data_type", r->data_type);
5221         ndr->depth++;
5222         if (r->data_type) {
5223                 ndr_print_string(ndr, "data_type", r->data_type);
5224         }
5225         ndr->depth--;
5226         ndr_print_ptr(ndr, "text_status", r->text_status);
5227         ndr->depth++;
5228         if (r->text_status) {
5229                 ndr_print_string(ndr, "text_status", r->text_status);
5230         }
5231         ndr->depth--;
5232         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5233         ndr_print_uint32(ndr, "priority", r->priority);
5234         ndr_print_uint32(ndr, "position", r->position);
5235         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5236         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5237         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5238         ndr->depth--;
5239 }
5240
5241 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5242 {
5243         if (ndr_flags & NDR_SCALARS) {
5244                 NDR_CHECK(ndr_push_align(ndr, 5));
5245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5246                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5247                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5248                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5249                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5258                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5265                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5268                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5269         }
5270         if (ndr_flags & NDR_BUFFERS) {
5271                 if (r->printer_name) {
5272                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5273                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5274                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5276                 }
5277                 if (r->server_name) {
5278                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5279                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5280                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5282                 }
5283                 if (r->user_name) {
5284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5287                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5288                 }
5289                 if (r->document_name) {
5290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5293                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5294                 }
5295                 if (r->notify_name) {
5296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5300                 }
5301                 if (r->data_type) {
5302                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5305                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5306                 }
5307                 if (r->print_processor) {
5308                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5311                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5312                 }
5313                 if (r->parameters) {
5314                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5317                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5318                 }
5319                 if (r->driver_name) {
5320                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5321                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5322                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5323                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5324                 }
5325                 if (r->text_status) {
5326                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5327                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5328                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5329                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5330                 }
5331         }
5332         return NDR_ERR_SUCCESS;
5333 }
5334
5335 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5336 {
5337         uint32_t _ptr_printer_name;
5338         uint32_t size_printer_name_1 = 0;
5339         uint32_t length_printer_name_1 = 0;
5340         TALLOC_CTX *_mem_save_printer_name_0;
5341         uint32_t _ptr_server_name;
5342         uint32_t size_server_name_1 = 0;
5343         uint32_t length_server_name_1 = 0;
5344         TALLOC_CTX *_mem_save_server_name_0;
5345         uint32_t _ptr_user_name;
5346         uint32_t size_user_name_1 = 0;
5347         uint32_t length_user_name_1 = 0;
5348         TALLOC_CTX *_mem_save_user_name_0;
5349         uint32_t _ptr_document_name;
5350         uint32_t size_document_name_1 = 0;
5351         uint32_t length_document_name_1 = 0;
5352         TALLOC_CTX *_mem_save_document_name_0;
5353         uint32_t _ptr_notify_name;
5354         uint32_t size_notify_name_1 = 0;
5355         uint32_t length_notify_name_1 = 0;
5356         TALLOC_CTX *_mem_save_notify_name_0;
5357         uint32_t _ptr_data_type;
5358         uint32_t size_data_type_1 = 0;
5359         uint32_t length_data_type_1 = 0;
5360         TALLOC_CTX *_mem_save_data_type_0;
5361         uint32_t _ptr_print_processor;
5362         uint32_t size_print_processor_1 = 0;
5363         uint32_t length_print_processor_1 = 0;
5364         TALLOC_CTX *_mem_save_print_processor_0;
5365         uint32_t _ptr_parameters;
5366         uint32_t size_parameters_1 = 0;
5367         uint32_t length_parameters_1 = 0;
5368         TALLOC_CTX *_mem_save_parameters_0;
5369         uint32_t _ptr_driver_name;
5370         uint32_t size_driver_name_1 = 0;
5371         uint32_t length_driver_name_1 = 0;
5372         TALLOC_CTX *_mem_save_driver_name_0;
5373         uint32_t _ptr_text_status;
5374         uint32_t size_text_status_1 = 0;
5375         uint32_t length_text_status_1 = 0;
5376         TALLOC_CTX *_mem_save_text_status_0;
5377         if (ndr_flags & NDR_SCALARS) {
5378                 NDR_CHECK(ndr_pull_align(ndr, 5));
5379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5380                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5381                 if (_ptr_printer_name) {
5382                         NDR_PULL_ALLOC(ndr, r->printer_name);
5383                 } else {
5384                         r->printer_name = NULL;
5385                 }
5386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5387                 if (_ptr_server_name) {
5388                         NDR_PULL_ALLOC(ndr, r->server_name);
5389                 } else {
5390                         r->server_name = NULL;
5391                 }
5392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5393                 if (_ptr_user_name) {
5394                         NDR_PULL_ALLOC(ndr, r->user_name);
5395                 } else {
5396                         r->user_name = NULL;
5397                 }
5398                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5399                 if (_ptr_document_name) {
5400                         NDR_PULL_ALLOC(ndr, r->document_name);
5401                 } else {
5402                         r->document_name = NULL;
5403                 }
5404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5405                 if (_ptr_notify_name) {
5406                         NDR_PULL_ALLOC(ndr, r->notify_name);
5407                 } else {
5408                         r->notify_name = NULL;
5409                 }
5410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5411                 if (_ptr_data_type) {
5412                         NDR_PULL_ALLOC(ndr, r->data_type);
5413                 } else {
5414                         r->data_type = NULL;
5415                 }
5416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5417                 if (_ptr_print_processor) {
5418                         NDR_PULL_ALLOC(ndr, r->print_processor);
5419                 } else {
5420                         r->print_processor = NULL;
5421                 }
5422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5423                 if (_ptr_parameters) {
5424                         NDR_PULL_ALLOC(ndr, r->parameters);
5425                 } else {
5426                         r->parameters = NULL;
5427                 }
5428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5429                 if (_ptr_driver_name) {
5430                         NDR_PULL_ALLOC(ndr, r->driver_name);
5431                 } else {
5432                         r->driver_name = NULL;
5433                 }
5434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5436                 if (_ptr_text_status) {
5437                         NDR_PULL_ALLOC(ndr, r->text_status);
5438                 } else {
5439                         r->text_status = NULL;
5440                 }
5441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5442                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5444                 if (r->priority > 99) {
5445                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5446                 }
5447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5452                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5455                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5456         }
5457         if (ndr_flags & NDR_BUFFERS) {
5458                 if (r->printer_name) {
5459                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5460                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5463                         size_printer_name_1 = ndr_get_array_size(ndr, &r->printer_name);
5464                         length_printer_name_1 = ndr_get_array_length(ndr, &r->printer_name);
5465                         if (length_printer_name_1 > size_printer_name_1) {
5466                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printer_name_1, length_printer_name_1);
5467                         }
5468                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printer_name_1, sizeof(uint16_t)));
5469                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, length_printer_name_1, sizeof(uint16_t), CH_UTF16));
5470                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5471                 }
5472                 if (r->server_name) {
5473                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5474                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5475                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5476                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5477                         size_server_name_1 = ndr_get_array_size(ndr, &r->server_name);
5478                         length_server_name_1 = ndr_get_array_length(ndr, &r->server_name);
5479                         if (length_server_name_1 > size_server_name_1) {
5480                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_name_1, length_server_name_1);
5481                         }
5482                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_name_1, sizeof(uint16_t)));
5483                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, length_server_name_1, sizeof(uint16_t), CH_UTF16));
5484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5485                 }
5486                 if (r->user_name) {
5487                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5488                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5489                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5490                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5491                         size_user_name_1 = ndr_get_array_size(ndr, &r->user_name);
5492                         length_user_name_1 = ndr_get_array_length(ndr, &r->user_name);
5493                         if (length_user_name_1 > size_user_name_1) {
5494                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_name_1, length_user_name_1);
5495                         }
5496                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_name_1, sizeof(uint16_t)));
5497                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, length_user_name_1, sizeof(uint16_t), CH_UTF16));
5498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5499                 }
5500                 if (r->document_name) {
5501                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5502                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5503                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5504                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5505                         size_document_name_1 = ndr_get_array_size(ndr, &r->document_name);
5506                         length_document_name_1 = ndr_get_array_length(ndr, &r->document_name);
5507                         if (length_document_name_1 > size_document_name_1) {
5508                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_document_name_1, length_document_name_1);
5509                         }
5510                         NDR_CHECK(ndr_check_string_terminator(ndr, length_document_name_1, sizeof(uint16_t)));
5511                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, length_document_name_1, sizeof(uint16_t), CH_UTF16));
5512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5513                 }
5514                 if (r->notify_name) {
5515                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5516                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5517                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5518                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5519                         size_notify_name_1 = ndr_get_array_size(ndr, &r->notify_name);
5520                         length_notify_name_1 = ndr_get_array_length(ndr, &r->notify_name);
5521                         if (length_notify_name_1 > size_notify_name_1) {
5522                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_notify_name_1, length_notify_name_1);
5523                         }
5524                         NDR_CHECK(ndr_check_string_terminator(ndr, length_notify_name_1, sizeof(uint16_t)));
5525                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, length_notify_name_1, sizeof(uint16_t), CH_UTF16));
5526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5527                 }
5528                 if (r->data_type) {
5529                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5530                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5533                         size_data_type_1 = ndr_get_array_size(ndr, &r->data_type);
5534                         length_data_type_1 = ndr_get_array_length(ndr, &r->data_type);
5535                         if (length_data_type_1 > size_data_type_1) {
5536                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_type_1, length_data_type_1);
5537                         }
5538                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_type_1, sizeof(uint16_t)));
5539                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, length_data_type_1, sizeof(uint16_t), CH_UTF16));
5540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5541                 }
5542                 if (r->print_processor) {
5543                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5544                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5545                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5546                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5547                         size_print_processor_1 = ndr_get_array_size(ndr, &r->print_processor);
5548                         length_print_processor_1 = ndr_get_array_length(ndr, &r->print_processor);
5549                         if (length_print_processor_1 > size_print_processor_1) {
5550                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_print_processor_1, length_print_processor_1);
5551                         }
5552                         NDR_CHECK(ndr_check_string_terminator(ndr, length_print_processor_1, sizeof(uint16_t)));
5553                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, length_print_processor_1, sizeof(uint16_t), CH_UTF16));
5554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5555                 }
5556                 if (r->parameters) {
5557                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5558                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5559                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5560                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5561                         size_parameters_1 = ndr_get_array_size(ndr, &r->parameters);
5562                         length_parameters_1 = ndr_get_array_length(ndr, &r->parameters);
5563                         if (length_parameters_1 > size_parameters_1) {
5564                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_parameters_1, length_parameters_1);
5565                         }
5566                         NDR_CHECK(ndr_check_string_terminator(ndr, length_parameters_1, sizeof(uint16_t)));
5567                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, length_parameters_1, sizeof(uint16_t), CH_UTF16));
5568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5569                 }
5570                 if (r->driver_name) {
5571                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5572                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5573                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5574                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5575                         size_driver_name_1 = ndr_get_array_size(ndr, &r->driver_name);
5576                         length_driver_name_1 = ndr_get_array_length(ndr, &r->driver_name);
5577                         if (length_driver_name_1 > size_driver_name_1) {
5578                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_name_1, length_driver_name_1);
5579                         }
5580                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_name_1, sizeof(uint16_t)));
5581                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, length_driver_name_1, sizeof(uint16_t), CH_UTF16));
5582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5583                 }
5584                 if (r->text_status) {
5585                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5586                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5587                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5588                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5589                         size_text_status_1 = ndr_get_array_size(ndr, &r->text_status);
5590                         length_text_status_1 = ndr_get_array_length(ndr, &r->text_status);
5591                         if (length_text_status_1 > size_text_status_1) {
5592                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_text_status_1, length_text_status_1);
5593                         }
5594                         NDR_CHECK(ndr_check_string_terminator(ndr, length_text_status_1, sizeof(uint16_t)));
5595                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, length_text_status_1, sizeof(uint16_t), CH_UTF16));
5596                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5597                 }
5598         }
5599         return NDR_ERR_SUCCESS;
5600 }
5601
5602 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5603 {
5604         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5605         ndr->depth++;
5606         ndr_print_uint32(ndr, "job_id", r->job_id);
5607         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5608         ndr->depth++;
5609         if (r->printer_name) {
5610                 ndr_print_string(ndr, "printer_name", r->printer_name);
5611         }
5612         ndr->depth--;
5613         ndr_print_ptr(ndr, "server_name", r->server_name);
5614         ndr->depth++;
5615         if (r->server_name) {
5616                 ndr_print_string(ndr, "server_name", r->server_name);
5617         }
5618         ndr->depth--;
5619         ndr_print_ptr(ndr, "user_name", r->user_name);
5620         ndr->depth++;
5621         if (r->user_name) {
5622                 ndr_print_string(ndr, "user_name", r->user_name);
5623         }
5624         ndr->depth--;
5625         ndr_print_ptr(ndr, "document_name", r->document_name);
5626         ndr->depth++;
5627         if (r->document_name) {
5628                 ndr_print_string(ndr, "document_name", r->document_name);
5629         }
5630         ndr->depth--;
5631         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5632         ndr->depth++;
5633         if (r->notify_name) {
5634                 ndr_print_string(ndr, "notify_name", r->notify_name);
5635         }
5636         ndr->depth--;
5637         ndr_print_ptr(ndr, "data_type", r->data_type);
5638         ndr->depth++;
5639         if (r->data_type) {
5640                 ndr_print_string(ndr, "data_type", r->data_type);
5641         }
5642         ndr->depth--;
5643         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5644         ndr->depth++;
5645         if (r->print_processor) {
5646                 ndr_print_string(ndr, "print_processor", r->print_processor);
5647         }
5648         ndr->depth--;
5649         ndr_print_ptr(ndr, "parameters", r->parameters);
5650         ndr->depth++;
5651         if (r->parameters) {
5652                 ndr_print_string(ndr, "parameters", r->parameters);
5653         }
5654         ndr->depth--;
5655         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5656         ndr->depth++;
5657         if (r->driver_name) {
5658                 ndr_print_string(ndr, "driver_name", r->driver_name);
5659         }
5660         ndr->depth--;
5661         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5662         ndr_print_ptr(ndr, "text_status", r->text_status);
5663         ndr->depth++;
5664         if (r->text_status) {
5665                 ndr_print_string(ndr, "text_status", r->text_status);
5666         }
5667         ndr->depth--;
5668         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5669         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5670         ndr_print_uint32(ndr, "priority", r->priority);
5671         ndr_print_uint32(ndr, "position", r->position);
5672         ndr_print_uint32(ndr, "start_time", r->start_time);
5673         ndr_print_uint32(ndr, "until_time", r->until_time);
5674         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5675         ndr_print_uint32(ndr, "size", r->size);
5676         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5677         ndr_print_uint32(ndr, "time", r->time);
5678         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5679         ndr->depth--;
5680 }
5681
5682 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5683 {
5684         if (ndr_flags & NDR_SCALARS) {
5685                 NDR_CHECK(ndr_push_align(ndr, 5));
5686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5693                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5699                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5706                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5710                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5711         }
5712         if (ndr_flags & NDR_BUFFERS) {
5713                 if (r->printer_name) {
5714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5717                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5718                 }
5719                 if (r->server_name) {
5720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5723                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5724                 }
5725                 if (r->user_name) {
5726                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5729                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5730                 }
5731                 if (r->document_name) {
5732                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5735                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5736                 }
5737                 if (r->notify_name) {
5738                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5741                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5742                 }
5743                 if (r->data_type) {
5744                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5745                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5747                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5748                 }
5749                 if (r->print_processor) {
5750                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5751                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5753                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5754                 }
5755                 if (r->parameters) {
5756                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5757                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5759                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5760                 }
5761                 if (r->driver_name) {
5762                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5763                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5765                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5766                 }
5767                 if (r->text_status) {
5768                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5771                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5772                 }
5773         }
5774         return NDR_ERR_SUCCESS;
5775 }
5776
5777 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5778 {
5779         uint32_t _ptr_printer_name;
5780         uint32_t size_printer_name_1 = 0;
5781         uint32_t length_printer_name_1 = 0;
5782         TALLOC_CTX *_mem_save_printer_name_0;
5783         uint32_t _ptr_server_name;
5784         uint32_t size_server_name_1 = 0;
5785         uint32_t length_server_name_1 = 0;
5786         TALLOC_CTX *_mem_save_server_name_0;
5787         uint32_t _ptr_user_name;
5788         uint32_t size_user_name_1 = 0;
5789         uint32_t length_user_name_1 = 0;
5790         TALLOC_CTX *_mem_save_user_name_0;
5791         uint32_t _ptr_document_name;
5792         uint32_t size_document_name_1 = 0;
5793         uint32_t length_document_name_1 = 0;
5794         TALLOC_CTX *_mem_save_document_name_0;
5795         uint32_t _ptr_notify_name;
5796         uint32_t size_notify_name_1 = 0;
5797         uint32_t length_notify_name_1 = 0;
5798         TALLOC_CTX *_mem_save_notify_name_0;
5799         uint32_t _ptr_data_type;
5800         uint32_t size_data_type_1 = 0;
5801         uint32_t length_data_type_1 = 0;
5802         TALLOC_CTX *_mem_save_data_type_0;
5803         uint32_t _ptr_print_processor;
5804         uint32_t size_print_processor_1 = 0;
5805         uint32_t length_print_processor_1 = 0;
5806         TALLOC_CTX *_mem_save_print_processor_0;
5807         uint32_t _ptr_parameters;
5808         uint32_t size_parameters_1 = 0;
5809         uint32_t length_parameters_1 = 0;
5810         TALLOC_CTX *_mem_save_parameters_0;
5811         uint32_t _ptr_driver_name;
5812         uint32_t size_driver_name_1 = 0;
5813         uint32_t length_driver_name_1 = 0;
5814         TALLOC_CTX *_mem_save_driver_name_0;
5815         uint32_t _ptr_text_status;
5816         uint32_t size_text_status_1 = 0;
5817         uint32_t length_text_status_1 = 0;
5818         TALLOC_CTX *_mem_save_text_status_0;
5819         if (ndr_flags & NDR_SCALARS) {
5820                 NDR_CHECK(ndr_pull_align(ndr, 5));
5821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5823                 if (_ptr_printer_name) {
5824                         NDR_PULL_ALLOC(ndr, r->printer_name);
5825                 } else {
5826                         r->printer_name = NULL;
5827                 }
5828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5829                 if (_ptr_server_name) {
5830                         NDR_PULL_ALLOC(ndr, r->server_name);
5831                 } else {
5832                         r->server_name = NULL;
5833                 }
5834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5835                 if (_ptr_user_name) {
5836                         NDR_PULL_ALLOC(ndr, r->user_name);
5837                 } else {
5838                         r->user_name = NULL;
5839                 }
5840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5841                 if (_ptr_document_name) {
5842                         NDR_PULL_ALLOC(ndr, r->document_name);
5843                 } else {
5844                         r->document_name = NULL;
5845                 }
5846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5847                 if (_ptr_notify_name) {
5848                         NDR_PULL_ALLOC(ndr, r->notify_name);
5849                 } else {
5850                         r->notify_name = NULL;
5851                 }
5852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5853                 if (_ptr_data_type) {
5854                         NDR_PULL_ALLOC(ndr, r->data_type);
5855                 } else {
5856                         r->data_type = NULL;
5857                 }
5858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5859                 if (_ptr_print_processor) {
5860                         NDR_PULL_ALLOC(ndr, r->print_processor);
5861                 } else {
5862                         r->print_processor = NULL;
5863                 }
5864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5865                 if (_ptr_parameters) {
5866                         NDR_PULL_ALLOC(ndr, r->parameters);
5867                 } else {
5868                         r->parameters = NULL;
5869                 }
5870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5871                 if (_ptr_driver_name) {
5872                         NDR_PULL_ALLOC(ndr, r->driver_name);
5873                 } else {
5874                         r->driver_name = NULL;
5875                 }
5876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5878                 if (_ptr_text_status) {
5879                         NDR_PULL_ALLOC(ndr, r->text_status);
5880                 } else {
5881                         r->text_status = NULL;
5882                 }
5883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5884                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5886                 if (r->priority > 99) {
5887                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5888                 }
5889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5894                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5898                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5899         }
5900         if (ndr_flags & NDR_BUFFERS) {
5901                 if (r->printer_name) {
5902                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5903                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5904                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5905                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5906                         size_printer_name_1 = ndr_get_array_size(ndr, &r->printer_name);
5907                         length_printer_name_1 = ndr_get_array_length(ndr, &r->printer_name);
5908                         if (length_printer_name_1 > size_printer_name_1) {
5909                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printer_name_1, length_printer_name_1);
5910                         }
5911                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printer_name_1, sizeof(uint16_t)));
5912                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, length_printer_name_1, sizeof(uint16_t), CH_UTF16));
5913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5914                 }
5915                 if (r->server_name) {
5916                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5917                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5918                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5919                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5920                         size_server_name_1 = ndr_get_array_size(ndr, &r->server_name);
5921                         length_server_name_1 = ndr_get_array_length(ndr, &r->server_name);
5922                         if (length_server_name_1 > size_server_name_1) {
5923                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_name_1, length_server_name_1);
5924                         }
5925                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_name_1, sizeof(uint16_t)));
5926                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, length_server_name_1, sizeof(uint16_t), CH_UTF16));
5927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5928                 }
5929                 if (r->user_name) {
5930                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5931                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5933                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5934                         size_user_name_1 = ndr_get_array_size(ndr, &r->user_name);
5935                         length_user_name_1 = ndr_get_array_length(ndr, &r->user_name);
5936                         if (length_user_name_1 > size_user_name_1) {
5937                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_name_1, length_user_name_1);
5938                         }
5939                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_name_1, sizeof(uint16_t)));
5940                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, length_user_name_1, sizeof(uint16_t), CH_UTF16));
5941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5942                 }
5943                 if (r->document_name) {
5944                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5945                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5948                         size_document_name_1 = ndr_get_array_size(ndr, &r->document_name);
5949                         length_document_name_1 = ndr_get_array_length(ndr, &r->document_name);
5950                         if (length_document_name_1 > size_document_name_1) {
5951                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_document_name_1, length_document_name_1);
5952                         }
5953                         NDR_CHECK(ndr_check_string_terminator(ndr, length_document_name_1, sizeof(uint16_t)));
5954                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, length_document_name_1, sizeof(uint16_t), CH_UTF16));
5955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5956                 }
5957                 if (r->notify_name) {
5958                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5959                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5960                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5961                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5962                         size_notify_name_1 = ndr_get_array_size(ndr, &r->notify_name);
5963                         length_notify_name_1 = ndr_get_array_length(ndr, &r->notify_name);
5964                         if (length_notify_name_1 > size_notify_name_1) {
5965                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_notify_name_1, length_notify_name_1);
5966                         }
5967                         NDR_CHECK(ndr_check_string_terminator(ndr, length_notify_name_1, sizeof(uint16_t)));
5968                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, length_notify_name_1, sizeof(uint16_t), CH_UTF16));
5969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5970                 }
5971                 if (r->data_type) {
5972                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5973                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5974                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5975                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5976                         size_data_type_1 = ndr_get_array_size(ndr, &r->data_type);
5977                         length_data_type_1 = ndr_get_array_length(ndr, &r->data_type);
5978                         if (length_data_type_1 > size_data_type_1) {
5979                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_type_1, length_data_type_1);
5980                         }
5981                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_type_1, sizeof(uint16_t)));
5982                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, length_data_type_1, sizeof(uint16_t), CH_UTF16));
5983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5984                 }
5985                 if (r->print_processor) {
5986                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5987                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5988                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5989                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5990                         size_print_processor_1 = ndr_get_array_size(ndr, &r->print_processor);
5991                         length_print_processor_1 = ndr_get_array_length(ndr, &r->print_processor);
5992                         if (length_print_processor_1 > size_print_processor_1) {
5993                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_print_processor_1, length_print_processor_1);
5994                         }
5995                         NDR_CHECK(ndr_check_string_terminator(ndr, length_print_processor_1, sizeof(uint16_t)));
5996                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, length_print_processor_1, sizeof(uint16_t), CH_UTF16));
5997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5998                 }
5999                 if (r->parameters) {
6000                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6001                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6002                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6003                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6004                         size_parameters_1 = ndr_get_array_size(ndr, &r->parameters);
6005                         length_parameters_1 = ndr_get_array_length(ndr, &r->parameters);
6006                         if (length_parameters_1 > size_parameters_1) {
6007                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_parameters_1, length_parameters_1);
6008                         }
6009                         NDR_CHECK(ndr_check_string_terminator(ndr, length_parameters_1, sizeof(uint16_t)));
6010                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, length_parameters_1, sizeof(uint16_t), CH_UTF16));
6011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6012                 }
6013                 if (r->driver_name) {
6014                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6015                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6017                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6018                         size_driver_name_1 = ndr_get_array_size(ndr, &r->driver_name);
6019                         length_driver_name_1 = ndr_get_array_length(ndr, &r->driver_name);
6020                         if (length_driver_name_1 > size_driver_name_1) {
6021                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_name_1, length_driver_name_1);
6022                         }
6023                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_name_1, sizeof(uint16_t)));
6024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, length_driver_name_1, sizeof(uint16_t), CH_UTF16));
6025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6026                 }
6027                 if (r->text_status) {
6028                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6032                         size_text_status_1 = ndr_get_array_size(ndr, &r->text_status);
6033                         length_text_status_1 = ndr_get_array_length(ndr, &r->text_status);
6034                         if (length_text_status_1 > size_text_status_1) {
6035                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_text_status_1, length_text_status_1);
6036                         }
6037                         NDR_CHECK(ndr_check_string_terminator(ndr, length_text_status_1, sizeof(uint16_t)));
6038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, length_text_status_1, sizeof(uint16_t), CH_UTF16));
6039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6040                 }
6041         }
6042         return NDR_ERR_SUCCESS;
6043 }
6044
6045 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6046 {
6047         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6048         ndr->depth++;
6049         ndr_print_uint32(ndr, "job_id", r->job_id);
6050         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6051         ndr->depth++;
6052         if (r->printer_name) {
6053                 ndr_print_string(ndr, "printer_name", r->printer_name);
6054         }
6055         ndr->depth--;
6056         ndr_print_ptr(ndr, "server_name", r->server_name);
6057         ndr->depth++;
6058         if (r->server_name) {
6059                 ndr_print_string(ndr, "server_name", r->server_name);
6060         }
6061         ndr->depth--;
6062         ndr_print_ptr(ndr, "user_name", r->user_name);
6063         ndr->depth++;
6064         if (r->user_name) {
6065                 ndr_print_string(ndr, "user_name", r->user_name);
6066         }
6067         ndr->depth--;
6068         ndr_print_ptr(ndr, "document_name", r->document_name);
6069         ndr->depth++;
6070         if (r->document_name) {
6071                 ndr_print_string(ndr, "document_name", r->document_name);
6072         }
6073         ndr->depth--;
6074         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6075         ndr->depth++;
6076         if (r->notify_name) {
6077                 ndr_print_string(ndr, "notify_name", r->notify_name);
6078         }
6079         ndr->depth--;
6080         ndr_print_ptr(ndr, "data_type", r->data_type);
6081         ndr->depth++;
6082         if (r->data_type) {
6083                 ndr_print_string(ndr, "data_type", r->data_type);
6084         }
6085         ndr->depth--;
6086         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6087         ndr->depth++;
6088         if (r->print_processor) {
6089                 ndr_print_string(ndr, "print_processor", r->print_processor);
6090         }
6091         ndr->depth--;
6092         ndr_print_ptr(ndr, "parameters", r->parameters);
6093         ndr->depth++;
6094         if (r->parameters) {
6095                 ndr_print_string(ndr, "parameters", r->parameters);
6096         }
6097         ndr->depth--;
6098         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6099         ndr->depth++;
6100         if (r->driver_name) {
6101                 ndr_print_string(ndr, "driver_name", r->driver_name);
6102         }
6103         ndr->depth--;
6104         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6105         ndr_print_ptr(ndr, "text_status", r->text_status);
6106         ndr->depth++;
6107         if (r->text_status) {
6108                 ndr_print_string(ndr, "text_status", r->text_status);
6109         }
6110         ndr->depth--;
6111         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6112         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6113         ndr_print_uint32(ndr, "priority", r->priority);
6114         ndr_print_uint32(ndr, "position", r->position);
6115         ndr_print_uint32(ndr, "start_time", r->start_time);
6116         ndr_print_uint32(ndr, "until_time", r->until_time);
6117         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6118         ndr_print_uint32(ndr, "size", r->size);
6119         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6120         ndr_print_uint32(ndr, "time", r->time);
6121         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6122         ndr_print_uint32(ndr, "size_high", r->size_high);
6123         ndr->depth--;
6124 }
6125
6126 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6127 {
6128         if (ndr_flags & NDR_SCALARS) {
6129                 int level = ndr_push_get_switch_value(ndr, r);
6130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6131                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6132                 switch (level) {
6133                         case 1: {
6134                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6135                         break; }
6136
6137                         case 2: {
6138                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6139                         break; }
6140
6141                         case 3: {
6142                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6143                         break; }
6144
6145                         case 4: {
6146                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6147                         break; }
6148
6149                         default: {
6150                         break; }
6151
6152                 }
6153         }
6154         if (ndr_flags & NDR_BUFFERS) {
6155                 int level = ndr_push_get_switch_value(ndr, r);
6156                 switch (level) {
6157                         case 1:
6158                                 if (r->info1) {
6159                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6160                                 }
6161                         break;
6162
6163                         case 2:
6164                                 if (r->info2) {
6165                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6166                                 }
6167                         break;
6168
6169                         case 3:
6170                                 if (r->info3) {
6171                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6172                                 }
6173                         break;
6174
6175                         case 4:
6176                                 if (r->info4) {
6177                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6178                                 }
6179                         break;
6180
6181                         default:
6182                         break;
6183
6184                 }
6185         }
6186         return NDR_ERR_SUCCESS;
6187 }
6188
6189 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6190 {
6191         int level;
6192         uint32_t _level;
6193         TALLOC_CTX *_mem_save_info1_0;
6194         uint32_t _ptr_info1;
6195         TALLOC_CTX *_mem_save_info2_0;
6196         uint32_t _ptr_info2;
6197         TALLOC_CTX *_mem_save_info3_0;
6198         uint32_t _ptr_info3;
6199         TALLOC_CTX *_mem_save_info4_0;
6200         uint32_t _ptr_info4;
6201         level = ndr_pull_get_switch_value(ndr, r);
6202         if (ndr_flags & NDR_SCALARS) {
6203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6204                 if (_level != level) {
6205                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6206                 }
6207                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6208                 switch (level) {
6209                         case 1: {
6210                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6211                                 if (_ptr_info1) {
6212                                         NDR_PULL_ALLOC(ndr, r->info1);
6213                                 } else {
6214                                         r->info1 = NULL;
6215                                 }
6216                         break; }
6217
6218                         case 2: {
6219                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6220                                 if (_ptr_info2) {
6221                                         NDR_PULL_ALLOC(ndr, r->info2);
6222                                 } else {
6223                                         r->info2 = NULL;
6224                                 }
6225                         break; }
6226
6227                         case 3: {
6228                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6229                                 if (_ptr_info3) {
6230                                         NDR_PULL_ALLOC(ndr, r->info3);
6231                                 } else {
6232                                         r->info3 = NULL;
6233                                 }
6234                         break; }
6235
6236                         case 4: {
6237                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6238                                 if (_ptr_info4) {
6239                                         NDR_PULL_ALLOC(ndr, r->info4);
6240                                 } else {
6241                                         r->info4 = NULL;
6242                                 }
6243                         break; }
6244
6245                         default: {
6246                         break; }
6247
6248                 }
6249         }
6250         if (ndr_flags & NDR_BUFFERS) {
6251                 switch (level) {
6252                         case 1:
6253                                 if (r->info1) {
6254                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6255                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6256                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6257                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6258                                 }
6259                         break;
6260
6261                         case 2:
6262                                 if (r->info2) {
6263                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6264                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6265                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6266                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6267                                 }
6268                         break;
6269
6270                         case 3:
6271                                 if (r->info3) {
6272                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6273                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6274                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6275                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6276                                 }
6277                         break;
6278
6279                         case 4:
6280                                 if (r->info4) {
6281                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6282                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6283                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6284                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6285                                 }
6286                         break;
6287
6288                         default:
6289                         break;
6290
6291                 }
6292         }
6293         return NDR_ERR_SUCCESS;
6294 }
6295
6296 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6297 {
6298         int level;
6299         level = ndr_print_get_switch_value(ndr, r);
6300         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6301         switch (level) {
6302                 case 1:
6303                         ndr_print_ptr(ndr, "info1", r->info1);
6304                         ndr->depth++;
6305                         if (r->info1) {
6306                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6307                         }
6308                         ndr->depth--;
6309                 break;
6310
6311                 case 2:
6312                         ndr_print_ptr(ndr, "info2", r->info2);
6313                         ndr->depth++;
6314                         if (r->info2) {
6315                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6316                         }
6317                         ndr->depth--;
6318                 break;
6319
6320                 case 3:
6321                         ndr_print_ptr(ndr, "info3", r->info3);
6322                         ndr->depth++;
6323                         if (r->info3) {
6324                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6325                         }
6326                         ndr->depth--;
6327                 break;
6328
6329                 case 4:
6330                         ndr_print_ptr(ndr, "info4", r->info4);
6331                         ndr->depth++;
6332                         if (r->info4) {
6333                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6334                         }
6335                         ndr->depth--;
6336                 break;
6337
6338                 default:
6339                 break;
6340
6341         }
6342 }
6343
6344 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6345 {
6346         if (ndr_flags & NDR_SCALARS) {
6347                 NDR_CHECK(ndr_push_align(ndr, 5));
6348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6349                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6350                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6351                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6352         }
6353         if (ndr_flags & NDR_BUFFERS) {
6354                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6355         }
6356         return NDR_ERR_SUCCESS;
6357 }
6358
6359 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6360 {
6361         if (ndr_flags & NDR_SCALARS) {
6362                 NDR_CHECK(ndr_pull_align(ndr, 5));
6363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6364                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6365                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6366                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6367         }
6368         if (ndr_flags & NDR_BUFFERS) {
6369                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6370         }
6371         return NDR_ERR_SUCCESS;
6372 }
6373
6374 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6375 {
6376         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6377         ndr->depth++;
6378         ndr_print_uint32(ndr, "level", r->level);
6379         ndr_print_set_switch_value(ndr, &r->info, r->level);
6380         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6381         ndr->depth--;
6382 }
6383
6384 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6385 {
6386         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6387         return NDR_ERR_SUCCESS;
6388 }
6389
6390 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6391 {
6392         uint32_t v;
6393         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6394         *r = v;
6395         return NDR_ERR_SUCCESS;
6396 }
6397
6398 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6399 {
6400         const char *val = NULL;
6401
6402         switch (r) {
6403                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6404                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6405                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6406                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6407                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6408                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6409                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6410                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6411                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6412         }
6413         ndr_print_enum(ndr, name, "ENUM", val, r);
6414 }
6415
6416 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6417 {
6418         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6419         return NDR_ERR_SUCCESS;
6420 }
6421
6422 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6423 {
6424         uint32_t v;
6425         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6426         *r = v;
6427         return NDR_ERR_SUCCESS;
6428 }
6429
6430 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6431 {
6432         const char *val = NULL;
6433
6434         switch (r) {
6435                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6436                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6437                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6438                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6439                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6440         }
6441         ndr_print_enum(ndr, name, "ENUM", val, r);
6442 }
6443
6444 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6445 {
6446         if (ndr_flags & NDR_SCALARS) {
6447                 NDR_CHECK(ndr_push_align(ndr, 5));
6448                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6453                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6465                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6468                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6472                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6473                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6477                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6478         }
6479         if (ndr_flags & NDR_BUFFERS) {
6480                 if (r->servername) {
6481                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6482                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6484                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6485                 }
6486                 if (r->printername) {
6487                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6488                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6489                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6490                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6491                 }
6492         }
6493         return NDR_ERR_SUCCESS;
6494 }
6495
6496 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6497 {
6498         uint32_t _ptr_servername;
6499         uint32_t size_servername_1 = 0;
6500         uint32_t length_servername_1 = 0;
6501         TALLOC_CTX *_mem_save_servername_0;
6502         uint32_t _ptr_printername;
6503         uint32_t size_printername_1 = 0;
6504         uint32_t length_printername_1 = 0;
6505         TALLOC_CTX *_mem_save_printername_0;
6506         if (ndr_flags & NDR_SCALARS) {
6507                 NDR_CHECK(ndr_pull_align(ndr, 5));
6508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6509                 if (_ptr_servername) {
6510                         NDR_PULL_ALLOC(ndr, r->servername);
6511                 } else {
6512                         r->servername = NULL;
6513                 }
6514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6515                 if (_ptr_printername) {
6516                         NDR_PULL_ALLOC(ndr, r->printername);
6517                 } else {
6518                         r->printername = NULL;
6519                 }
6520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6523                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6535                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6538                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6542                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6543                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6547                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6548         }
6549         if (ndr_flags & NDR_BUFFERS) {
6550                 if (r->servername) {
6551                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6552                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6553                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6554                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6555                         size_servername_1 = ndr_get_array_size(ndr, &r->servername);
6556                         length_servername_1 = ndr_get_array_length(ndr, &r->servername);
6557                         if (length_servername_1 > size_servername_1) {
6558                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
6559                         }
6560                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
6561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
6562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6563                 }
6564                 if (r->printername) {
6565                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6566                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6569                         size_printername_1 = ndr_get_array_size(ndr, &r->printername);
6570                         length_printername_1 = ndr_get_array_length(ndr, &r->printername);
6571                         if (length_printername_1 > size_printername_1) {
6572                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printername_1, length_printername_1);
6573                         }
6574                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printername_1, sizeof(uint16_t)));
6575                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, length_printername_1, sizeof(uint16_t), CH_UTF16));
6576                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6577                 }
6578         }
6579         return NDR_ERR_SUCCESS;
6580 }
6581
6582 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6583 {
6584         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6585         ndr->depth++;
6586         ndr_print_ptr(ndr, "servername", r->servername);
6587         ndr->depth++;
6588         if (r->servername) {
6589                 ndr_print_string(ndr, "servername", r->servername);
6590         }
6591         ndr->depth--;
6592         ndr_print_ptr(ndr, "printername", r->printername);
6593         ndr->depth++;
6594         if (r->printername) {
6595                 ndr_print_string(ndr, "printername", r->printername);
6596         }
6597         ndr->depth--;
6598         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6599         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6600         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6601         ndr_print_spoolss_Time(ndr, "time", &r->time);
6602         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6603         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6604         ndr_print_uint32(ndr, "version", r->version);
6605         ndr_print_uint32(ndr, "free_build", r->free_build);
6606         ndr_print_uint32(ndr, "spooling", r->spooling);
6607         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6608         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6609         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6610         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6611         ndr_print_uint32(ndr, "job_error", r->job_error);
6612         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6613         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6614         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6615         ndr_print_uint32(ndr, "change_id", r->change_id);
6616         ndr_print_WERROR(ndr, "last_error", r->last_error);
6617         ndr_print_uint32(ndr, "status", r->status);
6618         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6619         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6620         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6621         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6622         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6623         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6624         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6625         ndr->depth--;
6626 }
6627
6628 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6629 {
6630         if (ndr_flags & NDR_SCALARS) {
6631                 NDR_CHECK(ndr_push_align(ndr, 5));
6632                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6634                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6635                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6636                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6637         }
6638         if (ndr_flags & NDR_BUFFERS) {
6639                 if (r->description) {
6640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6643                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6644                 }
6645                 if (r->name) {
6646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6649                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6650                 }
6651                 if (r->comment) {
6652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6656                 }
6657         }
6658         return NDR_ERR_SUCCESS;
6659 }
6660
6661 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6662 {
6663         uint32_t _ptr_description;
6664         uint32_t size_description_1 = 0;
6665         uint32_t length_description_1 = 0;
6666         TALLOC_CTX *_mem_save_description_0;
6667         uint32_t _ptr_name;
6668         uint32_t size_name_1 = 0;
6669         uint32_t length_name_1 = 0;
6670         TALLOC_CTX *_mem_save_name_0;
6671         uint32_t _ptr_comment;
6672         uint32_t size_comment_1 = 0;
6673         uint32_t length_comment_1 = 0;
6674         TALLOC_CTX *_mem_save_comment_0;
6675         if (ndr_flags & NDR_SCALARS) {
6676                 NDR_CHECK(ndr_pull_align(ndr, 5));
6677                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6679                 if (_ptr_description) {
6680                         NDR_PULL_ALLOC(ndr, r->description);
6681                 } else {
6682                         r->description = NULL;
6683                 }
6684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6685                 if (_ptr_name) {
6686                         NDR_PULL_ALLOC(ndr, r->name);
6687                 } else {
6688                         r->name = NULL;
6689                 }
6690                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6691                 if (_ptr_comment) {
6692                         NDR_PULL_ALLOC(ndr, r->comment);
6693                 } else {
6694                         r->comment = NULL;
6695                 }
6696                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6697         }
6698         if (ndr_flags & NDR_BUFFERS) {
6699                 if (r->description) {
6700                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6701                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6702                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6703                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6704                         size_description_1 = ndr_get_array_size(ndr, &r->description);
6705                         length_description_1 = ndr_get_array_length(ndr, &r->description);
6706                         if (length_description_1 > size_description_1) {
6707                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_description_1, length_description_1);
6708                         }
6709                         NDR_CHECK(ndr_check_string_terminator(ndr, length_description_1, sizeof(uint16_t)));
6710                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, length_description_1, sizeof(uint16_t), CH_UTF16));
6711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6712                 }
6713                 if (r->name) {
6714                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6715                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6718                         size_name_1 = ndr_get_array_size(ndr, &r->name);
6719                         length_name_1 = ndr_get_array_length(ndr, &r->name);
6720                         if (length_name_1 > size_name_1) {
6721                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
6722                         }
6723                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
6724                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
6725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6726                 }
6727                 if (r->comment) {
6728                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6729                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6730                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6731                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6732                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
6733                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
6734                         if (length_comment_1 > size_comment_1) {
6735                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
6736                         }
6737                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
6738                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
6739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6740                 }
6741         }
6742         return NDR_ERR_SUCCESS;
6743 }
6744
6745 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6746 {
6747         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6748         ndr->depth++;
6749         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6750         ndr_print_ptr(ndr, "description", r->description);
6751         ndr->depth++;
6752         if (r->description) {
6753                 ndr_print_string(ndr, "description", r->description);
6754         }
6755         ndr->depth--;
6756         ndr_print_ptr(ndr, "name", r->name);
6757         ndr->depth++;
6758         if (r->name) {
6759                 ndr_print_string(ndr, "name", r->name);
6760         }
6761         ndr->depth--;
6762         ndr_print_ptr(ndr, "comment", r->comment);
6763         ndr->depth++;
6764         if (r->comment) {
6765                 ndr_print_string(ndr, "comment", r->comment);
6766         }
6767         ndr->depth--;
6768         ndr->depth--;
6769 }
6770
6771 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6772 {
6773         if (ndr_flags & NDR_SCALARS) {
6774                 NDR_CHECK(ndr_push_align(ndr, 5));
6775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6776                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6778                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
6783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secdesc_ptr));
6788                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6793                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6796                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6797         }
6798         if (ndr_flags & NDR_BUFFERS) {
6799                 if (r->servername) {
6800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6804                 }
6805                 if (r->printername) {
6806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6809                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6810                 }
6811                 if (r->sharename) {
6812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6816                 }
6817                 if (r->portname) {
6818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6822                 }
6823                 if (r->drivername) {
6824                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6828                 }
6829                 if (r->comment) {
6830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6833                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6834                 }
6835                 if (r->location) {
6836                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6837                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6839                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6840                 }
6841                 if (r->sepfile) {
6842                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6843                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6845                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6846                 }
6847                 if (r->printprocessor) {
6848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6849                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6851                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6852                 }
6853                 if (r->datatype) {
6854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6855                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6856                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6857                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6858                 }
6859                 if (r->parameters) {
6860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6861                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6862                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6863                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6864                 }
6865         }
6866         return NDR_ERR_SUCCESS;
6867 }
6868
6869 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6870 {
6871         uint32_t _ptr_servername;
6872         uint32_t size_servername_1 = 0;
6873         uint32_t length_servername_1 = 0;
6874         TALLOC_CTX *_mem_save_servername_0;
6875         uint32_t _ptr_printername;
6876         uint32_t size_printername_1 = 0;
6877         uint32_t length_printername_1 = 0;
6878         TALLOC_CTX *_mem_save_printername_0;
6879         uint32_t _ptr_sharename;
6880         uint32_t size_sharename_1 = 0;
6881         uint32_t length_sharename_1 = 0;
6882         TALLOC_CTX *_mem_save_sharename_0;
6883         uint32_t _ptr_portname;
6884         uint32_t size_portname_1 = 0;
6885         uint32_t length_portname_1 = 0;
6886         TALLOC_CTX *_mem_save_portname_0;
6887         uint32_t _ptr_drivername;
6888         uint32_t size_drivername_1 = 0;
6889         uint32_t length_drivername_1 = 0;
6890         TALLOC_CTX *_mem_save_drivername_0;
6891         uint32_t _ptr_comment;
6892         uint32_t size_comment_1 = 0;
6893         uint32_t length_comment_1 = 0;
6894         TALLOC_CTX *_mem_save_comment_0;
6895         uint32_t _ptr_location;
6896         uint32_t size_location_1 = 0;
6897         uint32_t length_location_1 = 0;
6898         TALLOC_CTX *_mem_save_location_0;
6899         uint32_t _ptr_sepfile;
6900         uint32_t size_sepfile_1 = 0;
6901         uint32_t length_sepfile_1 = 0;
6902         TALLOC_CTX *_mem_save_sepfile_0;
6903         uint32_t _ptr_printprocessor;
6904         uint32_t size_printprocessor_1 = 0;
6905         uint32_t length_printprocessor_1 = 0;
6906         TALLOC_CTX *_mem_save_printprocessor_0;
6907         uint32_t _ptr_datatype;
6908         uint32_t size_datatype_1 = 0;
6909         uint32_t length_datatype_1 = 0;
6910         TALLOC_CTX *_mem_save_datatype_0;
6911         uint32_t _ptr_parameters;
6912         uint32_t size_parameters_1 = 0;
6913         uint32_t length_parameters_1 = 0;
6914         TALLOC_CTX *_mem_save_parameters_0;
6915         if (ndr_flags & NDR_SCALARS) {
6916                 NDR_CHECK(ndr_pull_align(ndr, 5));
6917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6918                 if (_ptr_servername) {
6919                         NDR_PULL_ALLOC(ndr, r->servername);
6920                 } else {
6921                         r->servername = NULL;
6922                 }
6923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6924                 if (_ptr_printername) {
6925                         NDR_PULL_ALLOC(ndr, r->printername);
6926                 } else {
6927                         r->printername = NULL;
6928                 }
6929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6930                 if (_ptr_sharename) {
6931                         NDR_PULL_ALLOC(ndr, r->sharename);
6932                 } else {
6933                         r->sharename = NULL;
6934                 }
6935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6936                 if (_ptr_portname) {
6937                         NDR_PULL_ALLOC(ndr, r->portname);
6938                 } else {
6939                         r->portname = NULL;
6940                 }
6941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6942                 if (_ptr_drivername) {
6943                         NDR_PULL_ALLOC(ndr, r->drivername);
6944                 } else {
6945                         r->drivername = NULL;
6946                 }
6947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6948                 if (_ptr_comment) {
6949                         NDR_PULL_ALLOC(ndr, r->comment);
6950                 } else {
6951                         r->comment = NULL;
6952                 }
6953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6954                 if (_ptr_location) {
6955                         NDR_PULL_ALLOC(ndr, r->location);
6956                 } else {
6957                         r->location = NULL;
6958                 }
6959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
6960                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6961                 if (_ptr_sepfile) {
6962                         NDR_PULL_ALLOC(ndr, r->sepfile);
6963                 } else {
6964                         r->sepfile = NULL;
6965                 }
6966                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6967                 if (_ptr_printprocessor) {
6968                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6969                 } else {
6970                         r->printprocessor = NULL;
6971                 }
6972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6973                 if (_ptr_datatype) {
6974                         NDR_PULL_ALLOC(ndr, r->datatype);
6975                 } else {
6976                         r->datatype = NULL;
6977                 }
6978                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6979                 if (_ptr_parameters) {
6980                         NDR_PULL_ALLOC(ndr, r->parameters);
6981                 } else {
6982                         r->parameters = NULL;
6983                 }
6984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secdesc_ptr));
6985                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6987                 if (r->priority > 99) {
6988                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6989                 }
6990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6993                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6996                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6997         }
6998         if (ndr_flags & NDR_BUFFERS) {
6999                 if (r->servername) {
7000                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7001                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7002                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7003                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7004                         size_servername_1 = ndr_get_array_size(ndr, &r->servername);
7005                         length_servername_1 = ndr_get_array_length(ndr, &r->servername);
7006                         if (length_servername_1 > size_servername_1) {
7007                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
7008                         }
7009                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
7010                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
7011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7012                 }
7013                 if (r->printername) {
7014                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7015                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7017                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7018                         size_printername_1 = ndr_get_array_size(ndr, &r->printername);
7019                         length_printername_1 = ndr_get_array_length(ndr, &r->printername);
7020                         if (length_printername_1 > size_printername_1) {
7021                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printername_1, length_printername_1);
7022                         }
7023                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printername_1, sizeof(uint16_t)));
7024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, length_printername_1, sizeof(uint16_t), CH_UTF16));
7025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7026                 }
7027                 if (r->sharename) {
7028                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7029                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7032                         size_sharename_1 = ndr_get_array_size(ndr, &r->sharename);
7033                         length_sharename_1 = ndr_get_array_length(ndr, &r->sharename);
7034                         if (length_sharename_1 > size_sharename_1) {
7035                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_sharename_1, length_sharename_1);
7036                         }
7037                         NDR_CHECK(ndr_check_string_terminator(ndr, length_sharename_1, sizeof(uint16_t)));
7038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, length_sharename_1, sizeof(uint16_t), CH_UTF16));
7039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7040                 }
7041                 if (r->portname) {
7042                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7043                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7044                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7045                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7046                         size_portname_1 = ndr_get_array_size(ndr, &r->portname);
7047                         length_portname_1 = ndr_get_array_length(ndr, &r->portname);
7048                         if (length_portname_1 > size_portname_1) {
7049                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_portname_1, length_portname_1);
7050                         }
7051                         NDR_CHECK(ndr_check_string_terminator(ndr, length_portname_1, sizeof(uint16_t)));
7052                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, length_portname_1, sizeof(uint16_t), CH_UTF16));
7053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7054                 }
7055                 if (r->drivername) {
7056                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7057                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7058                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7059                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7060                         size_drivername_1 = ndr_get_array_size(ndr, &r->drivername);
7061                         length_drivername_1 = ndr_get_array_length(ndr, &r->drivername);
7062                         if (length_drivername_1 > size_drivername_1) {
7063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_drivername_1, length_drivername_1);
7064                         }
7065                         NDR_CHECK(ndr_check_string_terminator(ndr, length_drivername_1, sizeof(uint16_t)));
7066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, length_drivername_1, sizeof(uint16_t), CH_UTF16));
7067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7068                 }
7069                 if (r->comment) {
7070                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7071                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7074                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
7075                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
7076                         if (length_comment_1 > size_comment_1) {
7077                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
7078                         }
7079                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
7080                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
7081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7082                 }
7083                 if (r->location) {
7084                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7085                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7086                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7087                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7088                         size_location_1 = ndr_get_array_size(ndr, &r->location);
7089                         length_location_1 = ndr_get_array_length(ndr, &r->location);
7090                         if (length_location_1 > size_location_1) {
7091                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_location_1, length_location_1);
7092                         }
7093                         NDR_CHECK(ndr_check_string_terminator(ndr, length_location_1, sizeof(uint16_t)));
7094                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, length_location_1, sizeof(uint16_t), CH_UTF16));
7095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7096                 }
7097                 if (r->sepfile) {
7098                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7099                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7102                         size_sepfile_1 = ndr_get_array_size(ndr, &r->sepfile);
7103                         length_sepfile_1 = ndr_get_array_length(ndr, &r->sepfile);
7104                         if (length_sepfile_1 > size_sepfile_1) {
7105                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_sepfile_1, length_sepfile_1);
7106                         }
7107                         NDR_CHECK(ndr_check_string_terminator(ndr, length_sepfile_1, sizeof(uint16_t)));
7108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, length_sepfile_1, sizeof(uint16_t), CH_UTF16));
7109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7110                 }
7111                 if (r->printprocessor) {
7112                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7113                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7115                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7116                         size_printprocessor_1 = ndr_get_array_size(ndr, &r->printprocessor);
7117                         length_printprocessor_1 = ndr_get_array_length(ndr, &r->printprocessor);
7118                         if (length_printprocessor_1 > size_printprocessor_1) {
7119                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printprocessor_1, length_printprocessor_1);
7120                         }
7121                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printprocessor_1, sizeof(uint16_t)));
7122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, length_printprocessor_1, sizeof(uint16_t), CH_UTF16));
7123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7124                 }
7125                 if (r->datatype) {
7126                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7127                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7130                         size_datatype_1 = ndr_get_array_size(ndr, &r->datatype);
7131                         length_datatype_1 = ndr_get_array_length(ndr, &r->datatype);
7132                         if (length_datatype_1 > size_datatype_1) {
7133                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_datatype_1, length_datatype_1);
7134                         }
7135                         NDR_CHECK(ndr_check_string_terminator(ndr, length_datatype_1, sizeof(uint16_t)));
7136                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, length_datatype_1, sizeof(uint16_t), CH_UTF16));
7137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7138                 }
7139                 if (r->parameters) {
7140                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7141                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7142                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7143                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7144                         size_parameters_1 = ndr_get_array_size(ndr, &r->parameters);
7145                         length_parameters_1 = ndr_get_array_length(ndr, &r->parameters);
7146                         if (length_parameters_1 > size_parameters_1) {
7147                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_parameters_1, length_parameters_1);
7148                         }
7149                         NDR_CHECK(ndr_check_string_terminator(ndr, length_parameters_1, sizeof(uint16_t)));
7150                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, length_parameters_1, sizeof(uint16_t), CH_UTF16));
7151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7152                 }
7153         }
7154         return NDR_ERR_SUCCESS;
7155 }
7156
7157 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7158 {
7159         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7160         ndr->depth++;
7161         ndr_print_ptr(ndr, "servername", r->servername);
7162         ndr->depth++;
7163         if (r->servername) {
7164                 ndr_print_string(ndr, "servername", r->servername);
7165         }
7166         ndr->depth--;
7167         ndr_print_ptr(ndr, "printername", r->printername);
7168         ndr->depth++;
7169         if (r->printername) {
7170                 ndr_print_string(ndr, "printername", r->printername);
7171         }
7172         ndr->depth--;
7173         ndr_print_ptr(ndr, "sharename", r->sharename);
7174         ndr->depth++;
7175         if (r->sharename) {
7176                 ndr_print_string(ndr, "sharename", r->sharename);
7177         }
7178         ndr->depth--;
7179         ndr_print_ptr(ndr, "portname", r->portname);
7180         ndr->depth++;
7181         if (r->portname) {
7182                 ndr_print_string(ndr, "portname", r->portname);
7183         }
7184         ndr->depth--;
7185         ndr_print_ptr(ndr, "drivername", r->drivername);
7186         ndr->depth++;
7187         if (r->drivername) {
7188                 ndr_print_string(ndr, "drivername", r->drivername);
7189         }
7190         ndr->depth--;
7191         ndr_print_ptr(ndr, "comment", r->comment);
7192         ndr->depth++;
7193         if (r->comment) {
7194                 ndr_print_string(ndr, "comment", r->comment);
7195         }
7196         ndr->depth--;
7197         ndr_print_ptr(ndr, "location", r->location);
7198         ndr->depth++;
7199         if (r->location) {
7200                 ndr_print_string(ndr, "location", r->location);
7201         }
7202         ndr->depth--;
7203         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7204         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7205         ndr->depth++;
7206         if (r->sepfile) {
7207                 ndr_print_string(ndr, "sepfile", r->sepfile);
7208         }
7209         ndr->depth--;
7210         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7211         ndr->depth++;
7212         if (r->printprocessor) {
7213                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7214         }
7215         ndr->depth--;
7216         ndr_print_ptr(ndr, "datatype", r->datatype);
7217         ndr->depth++;
7218         if (r->datatype) {
7219                 ndr_print_string(ndr, "datatype", r->datatype);
7220         }
7221         ndr->depth--;
7222         ndr_print_ptr(ndr, "parameters", r->parameters);
7223         ndr->depth++;
7224         if (r->parameters) {
7225                 ndr_print_string(ndr, "parameters", r->parameters);
7226         }
7227         ndr->depth--;
7228         ndr_print_uint32(ndr, "secdesc_ptr", r->secdesc_ptr);
7229         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7230         ndr_print_uint32(ndr, "priority", r->priority);
7231         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7232         ndr_print_uint32(ndr, "starttime", r->starttime);
7233         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7234         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7235         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7236         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7237         ndr->depth--;
7238 }
7239
7240 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7241 {
7242         if (ndr_flags & NDR_SCALARS) {
7243                 NDR_CHECK(ndr_push_align(ndr, 4));
7244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7245                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7246         }
7247         if (ndr_flags & NDR_BUFFERS) {
7248         }
7249         return NDR_ERR_SUCCESS;
7250 }
7251
7252 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7253 {
7254         if (ndr_flags & NDR_SCALARS) {
7255                 NDR_CHECK(ndr_pull_align(ndr, 4));
7256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7257                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7258         }
7259         if (ndr_flags & NDR_BUFFERS) {
7260         }
7261         return NDR_ERR_SUCCESS;
7262 }
7263
7264 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7265 {
7266         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7267         ndr->depth++;
7268         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7269         ndr->depth--;
7270 }
7271
7272 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7273 {
7274         if (ndr_flags & NDR_SCALARS) {
7275                 NDR_CHECK(ndr_push_align(ndr, 5));
7276                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7277                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7278                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7279                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7280         }
7281         if (ndr_flags & NDR_BUFFERS) {
7282                 if (r->printername) {
7283                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7286                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7287                 }
7288                 if (r->servername) {
7289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7293                 }
7294         }
7295         return NDR_ERR_SUCCESS;
7296 }
7297
7298 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7299 {
7300         uint32_t _ptr_printername;
7301         uint32_t size_printername_1 = 0;
7302         uint32_t length_printername_1 = 0;
7303         TALLOC_CTX *_mem_save_printername_0;
7304         uint32_t _ptr_servername;
7305         uint32_t size_servername_1 = 0;
7306         uint32_t length_servername_1 = 0;
7307         TALLOC_CTX *_mem_save_servername_0;
7308         if (ndr_flags & NDR_SCALARS) {
7309                 NDR_CHECK(ndr_pull_align(ndr, 5));
7310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7311                 if (_ptr_printername) {
7312                         NDR_PULL_ALLOC(ndr, r->printername);
7313                 } else {
7314                         r->printername = NULL;
7315                 }
7316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7317                 if (_ptr_servername) {
7318                         NDR_PULL_ALLOC(ndr, r->servername);
7319                 } else {
7320                         r->servername = NULL;
7321                 }
7322                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7323                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7324         }
7325         if (ndr_flags & NDR_BUFFERS) {
7326                 if (r->printername) {
7327                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7328                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7331                         size_printername_1 = ndr_get_array_size(ndr, &r->printername);
7332                         length_printername_1 = ndr_get_array_length(ndr, &r->printername);
7333                         if (length_printername_1 > size_printername_1) {
7334                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printername_1, length_printername_1);
7335                         }
7336                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printername_1, sizeof(uint16_t)));
7337                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, length_printername_1, sizeof(uint16_t), CH_UTF16));
7338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7339                 }
7340                 if (r->servername) {
7341                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7342                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7343                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7344                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7345                         size_servername_1 = ndr_get_array_size(ndr, &r->servername);
7346                         length_servername_1 = ndr_get_array_length(ndr, &r->servername);
7347                         if (length_servername_1 > size_servername_1) {
7348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
7349                         }
7350                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
7351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
7352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7353                 }
7354         }
7355         return NDR_ERR_SUCCESS;
7356 }
7357
7358 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7359 {
7360         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7361         ndr->depth++;
7362         ndr_print_ptr(ndr, "printername", r->printername);
7363         ndr->depth++;
7364         if (r->printername) {
7365                 ndr_print_string(ndr, "printername", r->printername);
7366         }
7367         ndr->depth--;
7368         ndr_print_ptr(ndr, "servername", r->servername);
7369         ndr->depth++;
7370         if (r->servername) {
7371                 ndr_print_string(ndr, "servername", r->servername);
7372         }
7373         ndr->depth--;
7374         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7375         ndr->depth--;
7376 }
7377
7378 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7379 {
7380         if (ndr_flags & NDR_SCALARS) {
7381                 NDR_CHECK(ndr_push_align(ndr, 5));
7382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7384                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7387                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7388         }
7389         if (ndr_flags & NDR_BUFFERS) {
7390                 if (r->printername) {
7391                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7395                 }
7396                 if (r->portname) {
7397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7401                 }
7402         }
7403         return NDR_ERR_SUCCESS;
7404 }
7405
7406 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7407 {
7408         uint32_t _ptr_printername;
7409         uint32_t size_printername_1 = 0;
7410         uint32_t length_printername_1 = 0;
7411         TALLOC_CTX *_mem_save_printername_0;
7412         uint32_t _ptr_portname;
7413         uint32_t size_portname_1 = 0;
7414         uint32_t length_portname_1 = 0;
7415         TALLOC_CTX *_mem_save_portname_0;
7416         if (ndr_flags & NDR_SCALARS) {
7417                 NDR_CHECK(ndr_pull_align(ndr, 5));
7418                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7419                 if (_ptr_printername) {
7420                         NDR_PULL_ALLOC(ndr, r->printername);
7421                 } else {
7422                         r->printername = NULL;
7423                 }
7424                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7425                 if (_ptr_portname) {
7426                         NDR_PULL_ALLOC(ndr, r->portname);
7427                 } else {
7428                         r->portname = NULL;
7429                 }
7430                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7433                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7434         }
7435         if (ndr_flags & NDR_BUFFERS) {
7436                 if (r->printername) {
7437                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7438                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7439                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7440                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7441                         size_printername_1 = ndr_get_array_size(ndr, &r->printername);
7442                         length_printername_1 = ndr_get_array_length(ndr, &r->printername);
7443                         if (length_printername_1 > size_printername_1) {
7444                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printername_1, length_printername_1);
7445                         }
7446                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printername_1, sizeof(uint16_t)));
7447                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, length_printername_1, sizeof(uint16_t), CH_UTF16));
7448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7449                 }
7450                 if (r->portname) {
7451                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7452                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7453                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7454                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7455                         size_portname_1 = ndr_get_array_size(ndr, &r->portname);
7456                         length_portname_1 = ndr_get_array_length(ndr, &r->portname);
7457                         if (length_portname_1 > size_portname_1) {
7458                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_portname_1, length_portname_1);
7459                         }
7460                         NDR_CHECK(ndr_check_string_terminator(ndr, length_portname_1, sizeof(uint16_t)));
7461                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, length_portname_1, sizeof(uint16_t), CH_UTF16));
7462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7463                 }
7464         }
7465         return NDR_ERR_SUCCESS;
7466 }
7467
7468 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7469 {
7470         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7471         ndr->depth++;
7472         ndr_print_ptr(ndr, "printername", r->printername);
7473         ndr->depth++;
7474         if (r->printername) {
7475                 ndr_print_string(ndr, "printername", r->printername);
7476         }
7477         ndr->depth--;
7478         ndr_print_ptr(ndr, "portname", r->portname);
7479         ndr->depth++;
7480         if (r->portname) {
7481                 ndr_print_string(ndr, "portname", r->portname);
7482         }
7483         ndr->depth--;
7484         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7485         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7486         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7487         ndr->depth--;
7488 }
7489
7490 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7491 {
7492         if (ndr_flags & NDR_SCALARS) {
7493                 NDR_CHECK(ndr_push_align(ndr, 4));
7494                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7495                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7496         }
7497         if (ndr_flags & NDR_BUFFERS) {
7498         }
7499         return NDR_ERR_SUCCESS;
7500 }
7501
7502 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7503 {
7504         if (ndr_flags & NDR_SCALARS) {
7505                 NDR_CHECK(ndr_pull_align(ndr, 4));
7506                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7507                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7508         }
7509         if (ndr_flags & NDR_BUFFERS) {
7510         }
7511         return NDR_ERR_SUCCESS;
7512 }
7513
7514 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7515 {
7516         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7517         ndr->depth++;
7518         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7519         ndr->depth--;
7520 }
7521
7522 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7523 {
7524         if (ndr_flags & NDR_SCALARS) {
7525                 NDR_CHECK(ndr_push_align(ndr, 5));
7526                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7527                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7528                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7529         }
7530         if (ndr_flags & NDR_BUFFERS) {
7531                 if (r->guid) {
7532                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7533                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7535                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7536                 }
7537         }
7538         return NDR_ERR_SUCCESS;
7539 }
7540
7541 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7542 {
7543         uint32_t _ptr_guid;
7544         uint32_t size_guid_1 = 0;
7545         uint32_t length_guid_1 = 0;
7546         TALLOC_CTX *_mem_save_guid_0;
7547         if (ndr_flags & NDR_SCALARS) {
7548                 NDR_CHECK(ndr_pull_align(ndr, 5));
7549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7550                 if (_ptr_guid) {
7551                         NDR_PULL_ALLOC(ndr, r->guid);
7552                 } else {
7553                         r->guid = NULL;
7554                 }
7555                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7556                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7557         }
7558         if (ndr_flags & NDR_BUFFERS) {
7559                 if (r->guid) {
7560                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7561                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7564                         size_guid_1 = ndr_get_array_size(ndr, &r->guid);
7565                         length_guid_1 = ndr_get_array_length(ndr, &r->guid);
7566                         if (length_guid_1 > size_guid_1) {
7567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_guid_1, length_guid_1);
7568                         }
7569                         NDR_CHECK(ndr_check_string_terminator(ndr, length_guid_1, sizeof(uint16_t)));
7570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, length_guid_1, sizeof(uint16_t), CH_UTF16));
7571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7572                 }
7573         }
7574         return NDR_ERR_SUCCESS;
7575 }
7576
7577 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7578 {
7579         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7580         ndr->depth++;
7581         ndr_print_ptr(ndr, "guid", r->guid);
7582         ndr->depth++;
7583         if (r->guid) {
7584                 ndr_print_string(ndr, "guid", r->guid);
7585         }
7586         ndr->depth--;
7587         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7588         ndr->depth--;
7589 }
7590
7591 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo8 *r)
7592 {
7593         if (ndr_flags & NDR_SCALARS) {
7594                 NDR_CHECK(ndr_push_align(ndr, 4));
7595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7596                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7597         }
7598         if (ndr_flags & NDR_BUFFERS) {
7599         }
7600         return NDR_ERR_SUCCESS;
7601 }
7602
7603 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo8 *r)
7604 {
7605         if (ndr_flags & NDR_SCALARS) {
7606                 NDR_CHECK(ndr_pull_align(ndr, 4));
7607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7608                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7609         }
7610         if (ndr_flags & NDR_BUFFERS) {
7611         }
7612         return NDR_ERR_SUCCESS;
7613 }
7614
7615 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo8 *r)
7616 {
7617         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo8");
7618         ndr->depth++;
7619         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7620         ndr->depth--;
7621 }
7622
7623 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo9(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo9 *r)
7624 {
7625         if (ndr_flags & NDR_SCALARS) {
7626                 NDR_CHECK(ndr_push_align(ndr, 4));
7627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7628                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7629         }
7630         if (ndr_flags & NDR_BUFFERS) {
7631         }
7632         return NDR_ERR_SUCCESS;
7633 }
7634
7635 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo9(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo9 *r)
7636 {
7637         if (ndr_flags & NDR_SCALARS) {
7638                 NDR_CHECK(ndr_pull_align(ndr, 4));
7639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7640                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7641         }
7642         if (ndr_flags & NDR_BUFFERS) {
7643         }
7644         return NDR_ERR_SUCCESS;
7645 }
7646
7647 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo9(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo9 *r)
7648 {
7649         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo9");
7650         ndr->depth++;
7651         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7652         ndr->depth--;
7653 }
7654
7655 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7656 {
7657         if (ndr_flags & NDR_SCALARS) {
7658                 int level = ndr_push_get_switch_value(ndr, r);
7659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7660                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7661                 switch (level) {
7662                         case 0: {
7663                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7664                         break; }
7665
7666                         case 1: {
7667                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7668                         break; }
7669
7670                         case 2: {
7671                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7672                         break; }
7673
7674                         case 3: {
7675                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7676                         break; }
7677
7678                         case 4: {
7679                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7680                         break; }
7681
7682                         case 5: {
7683                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7684                         break; }
7685
7686                         case 6: {
7687                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7688                         break; }
7689
7690                         case 7: {
7691                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7692                         break; }
7693
7694                         case 8: {
7695                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7696                         break; }
7697
7698                         case 9: {
7699                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7700                         break; }
7701
7702                         default: {
7703                         break; }
7704
7705                 }
7706         }
7707         if (ndr_flags & NDR_BUFFERS) {
7708                 int level = ndr_push_get_switch_value(ndr, r);
7709                 switch (level) {
7710                         case 0:
7711                                 if (r->info0) {
7712                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7713                                 }
7714                         break;
7715
7716                         case 1:
7717                                 if (r->info1) {
7718                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7719                                 }
7720                         break;
7721
7722                         case 2:
7723                                 if (r->info2) {
7724                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7725                                 }
7726                         break;
7727
7728                         case 3:
7729                                 if (r->info3) {
7730                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7731                                 }
7732                         break;
7733
7734                         case 4:
7735                                 if (r->info4) {
7736                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7737                                 }
7738                         break;
7739
7740                         case 5:
7741                                 if (r->info5) {
7742                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7743                                 }
7744                         break;
7745
7746                         case 6:
7747                                 if (r->info6) {
7748                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7749                                 }
7750                         break;
7751
7752                         case 7:
7753                                 if (r->info7) {
7754                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7755                                 }
7756                         break;
7757
7758                         case 8:
7759                                 if (r->info8) {
7760                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7761                                 }
7762                         break;
7763
7764                         case 9:
7765                                 if (r->info9) {
7766                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7767                                 }
7768                         break;
7769
7770                         default:
7771                         break;
7772
7773                 }
7774         }
7775         return NDR_ERR_SUCCESS;
7776 }
7777
7778 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7779 {
7780         int level;
7781         uint32_t _level;
7782         TALLOC_CTX *_mem_save_info0_0;
7783         uint32_t _ptr_info0;
7784         TALLOC_CTX *_mem_save_info1_0;
7785         uint32_t _ptr_info1;
7786         TALLOC_CTX *_mem_save_info2_0;
7787         uint32_t _ptr_info2;
7788         TALLOC_CTX *_mem_save_info3_0;
7789         uint32_t _ptr_info3;
7790         TALLOC_CTX *_mem_save_info4_0;
7791         uint32_t _ptr_info4;
7792         TALLOC_CTX *_mem_save_info5_0;
7793         uint32_t _ptr_info5;
7794         TALLOC_CTX *_mem_save_info6_0;
7795         uint32_t _ptr_info6;
7796         TALLOC_CTX *_mem_save_info7_0;
7797         uint32_t _ptr_info7;
7798         TALLOC_CTX *_mem_save_info8_0;
7799         uint32_t _ptr_info8;
7800         TALLOC_CTX *_mem_save_info9_0;
7801         uint32_t _ptr_info9;
7802         level = ndr_pull_get_switch_value(ndr, r);
7803         if (ndr_flags & NDR_SCALARS) {
7804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7805                 if (_level != level) {
7806                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7807                 }
7808                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7809                 switch (level) {
7810                         case 0: {
7811                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7812                                 if (_ptr_info0) {
7813                                         NDR_PULL_ALLOC(ndr, r->info0);
7814                                 } else {
7815                                         r->info0 = NULL;
7816                                 }
7817                         break; }
7818
7819                         case 1: {
7820                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7821                                 if (_ptr_info1) {
7822                                         NDR_PULL_ALLOC(ndr, r->info1);
7823                                 } else {
7824                                         r->info1 = NULL;
7825                                 }
7826                         break; }
7827
7828                         case 2: {
7829                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7830                                 if (_ptr_info2) {
7831                                         NDR_PULL_ALLOC(ndr, r->info2);
7832                                 } else {
7833                                         r->info2 = NULL;
7834                                 }
7835                         break; }
7836
7837                         case 3: {
7838                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7839                                 if (_ptr_info3) {
7840                                         NDR_PULL_ALLOC(ndr, r->info3);
7841                                 } else {
7842                                         r->info3 = NULL;
7843                                 }
7844                         break; }
7845
7846                         case 4: {
7847                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7848                                 if (_ptr_info4) {
7849                                         NDR_PULL_ALLOC(ndr, r->info4);
7850                                 } else {
7851                                         r->info4 = NULL;
7852                                 }
7853                         break; }
7854
7855                         case 5: {
7856                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7857                                 if (_ptr_info5) {
7858                                         NDR_PULL_ALLOC(ndr, r->info5);
7859                                 } else {
7860                                         r->info5 = NULL;
7861                                 }
7862                         break; }
7863
7864                         case 6: {
7865                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7866                                 if (_ptr_info6) {
7867                                         NDR_PULL_ALLOC(ndr, r->info6);
7868                                 } else {
7869                                         r->info6 = NULL;
7870                                 }
7871                         break; }
7872
7873                         case 7: {
7874                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7875                                 if (_ptr_info7) {
7876                                         NDR_PULL_ALLOC(ndr, r->info7);
7877                                 } else {
7878                                         r->info7 = NULL;
7879                                 }
7880                         break; }
7881
7882                         case 8: {
7883                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7884                                 if (_ptr_info8) {
7885                                         NDR_PULL_ALLOC(ndr, r->info8);
7886                                 } else {
7887                                         r->info8 = NULL;
7888                                 }
7889                         break; }
7890
7891                         case 9: {
7892                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7893                                 if (_ptr_info9) {
7894                                         NDR_PULL_ALLOC(ndr, r->info9);
7895                                 } else {
7896                                         r->info9 = NULL;
7897                                 }
7898                         break; }
7899
7900                         default: {
7901                         break; }
7902
7903                 }
7904         }
7905         if (ndr_flags & NDR_BUFFERS) {
7906                 switch (level) {
7907                         case 0:
7908                                 if (r->info0) {
7909                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7910                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7911                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7912                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7913                                 }
7914                         break;
7915
7916                         case 1:
7917                                 if (r->info1) {
7918                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7919                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7920                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7921                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7922                                 }
7923                         break;
7924
7925                         case 2:
7926                                 if (r->info2) {
7927                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7928                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7929                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7930                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7931                                 }
7932                         break;
7933
7934                         case 3:
7935                                 if (r->info3) {
7936                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7937                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7938                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7939                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7940                                 }
7941                         break;
7942
7943                         case 4:
7944                                 if (r->info4) {
7945                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7946                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7947                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7948                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7949                                 }
7950                         break;
7951
7952                         case 5:
7953                                 if (r->info5) {
7954                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7955                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7956                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7957                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7958                                 }
7959                         break;
7960
7961                         case 6:
7962                                 if (r->info6) {
7963                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7964                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7965                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7966                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7967                                 }
7968                         break;
7969
7970                         case 7:
7971                                 if (r->info7) {
7972                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7973                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7974                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7975                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7976                                 }
7977                         break;
7978
7979                         case 8:
7980                                 if (r->info8) {
7981                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7982                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7983                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7984                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7985                                 }
7986                         break;
7987
7988                         case 9:
7989                                 if (r->info9) {
7990                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7991                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7992                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7993                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7994                                 }
7995                         break;
7996
7997                         default:
7998                         break;
7999
8000                 }
8001         }
8002         return NDR_ERR_SUCCESS;
8003 }
8004
8005 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
8006 {
8007         int level;
8008         level = ndr_print_get_switch_value(ndr, r);
8009         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
8010         switch (level) {
8011                 case 0:
8012                         ndr_print_ptr(ndr, "info0", r->info0);
8013                         ndr->depth++;
8014                         if (r->info0) {
8015                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
8016                         }
8017                         ndr->depth--;
8018                 break;
8019
8020                 case 1:
8021                         ndr_print_ptr(ndr, "info1", r->info1);
8022                         ndr->depth++;
8023                         if (r->info1) {
8024                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
8025                         }
8026                         ndr->depth--;
8027                 break;
8028
8029                 case 2:
8030                         ndr_print_ptr(ndr, "info2", r->info2);
8031                         ndr->depth++;
8032                         if (r->info2) {
8033                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
8034                         }
8035                         ndr->depth--;
8036                 break;
8037
8038                 case 3:
8039                         ndr_print_ptr(ndr, "info3", r->info3);
8040                         ndr->depth++;
8041                         if (r->info3) {
8042                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
8043                         }
8044                         ndr->depth--;
8045                 break;
8046
8047                 case 4:
8048                         ndr_print_ptr(ndr, "info4", r->info4);
8049                         ndr->depth++;
8050                         if (r->info4) {
8051                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
8052                         }
8053                         ndr->depth--;
8054                 break;
8055
8056                 case 5:
8057                         ndr_print_ptr(ndr, "info5", r->info5);
8058                         ndr->depth++;
8059                         if (r->info5) {
8060                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
8061                         }
8062                         ndr->depth--;
8063                 break;
8064
8065                 case 6:
8066                         ndr_print_ptr(ndr, "info6", r->info6);
8067                         ndr->depth++;
8068                         if (r->info6) {
8069                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8070                         }
8071                         ndr->depth--;
8072                 break;
8073
8074                 case 7:
8075                         ndr_print_ptr(ndr, "info7", r->info7);
8076                         ndr->depth++;
8077                         if (r->info7) {
8078                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8079                         }
8080                         ndr->depth--;
8081                 break;
8082
8083                 case 8:
8084                         ndr_print_ptr(ndr, "info8", r->info8);
8085                         ndr->depth++;
8086                         if (r->info8) {
8087                                 ndr_print_spoolss_SetPrinterInfo8(ndr, "info8", r->info8);
8088                         }
8089                         ndr->depth--;
8090                 break;
8091
8092                 case 9:
8093                         ndr_print_ptr(ndr, "info9", r->info9);
8094                         ndr->depth++;
8095                         if (r->info9) {
8096                                 ndr_print_spoolss_SetPrinterInfo9(ndr, "info9", r->info9);
8097                         }
8098                         ndr->depth--;
8099                 break;
8100
8101                 default:
8102                 break;
8103
8104         }
8105 }
8106
8107 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8108 {
8109         if (ndr_flags & NDR_SCALARS) {
8110                 NDR_CHECK(ndr_push_align(ndr, 5));
8111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8112                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8113                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8114                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8115         }
8116         if (ndr_flags & NDR_BUFFERS) {
8117                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8118         }
8119         return NDR_ERR_SUCCESS;
8120 }
8121
8122 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8123 {
8124         if (ndr_flags & NDR_SCALARS) {
8125                 NDR_CHECK(ndr_pull_align(ndr, 5));
8126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8127                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8128                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8129                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8130         }
8131         if (ndr_flags & NDR_BUFFERS) {
8132                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8133         }
8134         return NDR_ERR_SUCCESS;
8135 }
8136
8137 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8138 {
8139         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8140         ndr->depth++;
8141         ndr_print_uint32(ndr, "level", r->level);
8142         ndr_print_set_switch_value(ndr, &r->info, r->level);
8143         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8144         ndr->depth--;
8145 }
8146
8147 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8148 {
8149         if (ndr_flags & NDR_SCALARS) {
8150                 NDR_CHECK(ndr_push_align(ndr, 4));
8151                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8152                 {
8153                         uint32_t _flags_save_string_array = ndr->flags;
8154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
8155                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8156                         ndr->flags = _flags_save_string_array;
8157                 }
8158                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8159         }
8160         if (ndr_flags & NDR_BUFFERS) {
8161         }
8162         return NDR_ERR_SUCCESS;
8163 }
8164
8165 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8166 {
8167         if (ndr_flags & NDR_SCALARS) {
8168                 NDR_CHECK(ndr_pull_align(ndr, 4));
8169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8170                 {
8171                         uint32_t _flags_save_string_array = ndr->flags;
8172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
8173                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8174                         ndr->flags = _flags_save_string_array;
8175                 }
8176                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8177         }
8178         if (ndr_flags & NDR_BUFFERS) {
8179         }
8180         return NDR_ERR_SUCCESS;
8181 }
8182
8183 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8184 {
8185         ndr_print_struct(ndr, name, "spoolss_StringArray");
8186         ndr->depth++;
8187         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);
8188         ndr_print_string_array(ndr, "string", r->string);
8189         ndr->depth--;
8190 }
8191
8192 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8193 {
8194         if (ndr_flags & NDR_SCALARS) {
8195                 NDR_CHECK(ndr_push_align(ndr, 5));
8196                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8197                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8198         }
8199         if (ndr_flags & NDR_BUFFERS) {
8200                 if (r->driver_name) {
8201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8203                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8204                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8205                 }
8206         }
8207         return NDR_ERR_SUCCESS;
8208 }
8209
8210 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8211 {
8212         uint32_t _ptr_driver_name;
8213         uint32_t size_driver_name_1 = 0;
8214         uint32_t length_driver_name_1 = 0;
8215         TALLOC_CTX *_mem_save_driver_name_0;
8216         if (ndr_flags & NDR_SCALARS) {
8217                 NDR_CHECK(ndr_pull_align(ndr, 5));
8218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8219                 if (_ptr_driver_name) {
8220                         NDR_PULL_ALLOC(ndr, r->driver_name);
8221                 } else {
8222                         r->driver_name = NULL;
8223                 }
8224                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8225         }
8226         if (ndr_flags & NDR_BUFFERS) {
8227                 if (r->driver_name) {
8228                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8229                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8230                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8231                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8232                         size_driver_name_1 = ndr_get_array_size(ndr, &r->driver_name);
8233                         length_driver_name_1 = ndr_get_array_length(ndr, &r->driver_name);
8234                         if (length_driver_name_1 > size_driver_name_1) {
8235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_name_1, length_driver_name_1);
8236                         }
8237                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_name_1, sizeof(uint16_t)));
8238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, length_driver_name_1, sizeof(uint16_t), CH_UTF16));
8239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8240                 }
8241         }
8242         return NDR_ERR_SUCCESS;
8243 }
8244
8245 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8246 {
8247         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8248         ndr->depth++;
8249         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8250         ndr->depth++;
8251         if (r->driver_name) {
8252                 ndr_print_string(ndr, "driver_name", r->driver_name);
8253         }
8254         ndr->depth--;
8255         ndr->depth--;
8256 }
8257
8258 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8259 {
8260         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8261         return NDR_ERR_SUCCESS;
8262 }
8263
8264 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8265 {
8266         uint32_t v;
8267         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8268         *r = v;
8269         return NDR_ERR_SUCCESS;
8270 }
8271
8272 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8273 {
8274         const char *val = NULL;
8275
8276         switch (r) {
8277                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8278                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8279                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8280                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8281         }
8282         ndr_print_enum(ndr, name, "ENUM", val, r);
8283 }
8284
8285 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8286 {
8287         if (ndr_flags & NDR_SCALARS) {
8288                 NDR_CHECK(ndr_push_align(ndr, 5));
8289                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8291                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8293                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8295                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8296         }
8297         if (ndr_flags & NDR_BUFFERS) {
8298                 if (r->driver_name) {
8299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8300                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8301                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8302                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8303                 }
8304                 if (r->architecture) {
8305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8306                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8307                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8308                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8309                 }
8310                 if (r->driver_path) {
8311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8313                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8315                 }
8316                 if (r->data_file) {
8317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8319                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8320                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8321                 }
8322                 if (r->config_file) {
8323                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8324                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8325                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8326                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8327                 }
8328         }
8329         return NDR_ERR_SUCCESS;
8330 }
8331
8332 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8333 {
8334         uint32_t _ptr_driver_name;
8335         uint32_t size_driver_name_1 = 0;
8336         uint32_t length_driver_name_1 = 0;
8337         TALLOC_CTX *_mem_save_driver_name_0;
8338         uint32_t _ptr_architecture;
8339         uint32_t size_architecture_1 = 0;
8340         uint32_t length_architecture_1 = 0;
8341         TALLOC_CTX *_mem_save_architecture_0;
8342         uint32_t _ptr_driver_path;
8343         uint32_t size_driver_path_1 = 0;
8344         uint32_t length_driver_path_1 = 0;
8345         TALLOC_CTX *_mem_save_driver_path_0;
8346         uint32_t _ptr_data_file;
8347         uint32_t size_data_file_1 = 0;
8348         uint32_t length_data_file_1 = 0;
8349         TALLOC_CTX *_mem_save_data_file_0;
8350         uint32_t _ptr_config_file;
8351         uint32_t size_config_file_1 = 0;
8352         uint32_t length_config_file_1 = 0;
8353         TALLOC_CTX *_mem_save_config_file_0;
8354         if (ndr_flags & NDR_SCALARS) {
8355                 NDR_CHECK(ndr_pull_align(ndr, 5));
8356                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8358                 if (_ptr_driver_name) {
8359                         NDR_PULL_ALLOC(ndr, r->driver_name);
8360                 } else {
8361                         r->driver_name = NULL;
8362                 }
8363                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8364                 if (_ptr_architecture) {
8365                         NDR_PULL_ALLOC(ndr, r->architecture);
8366                 } else {
8367                         r->architecture = NULL;
8368                 }
8369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8370                 if (_ptr_driver_path) {
8371                         NDR_PULL_ALLOC(ndr, r->driver_path);
8372                 } else {
8373                         r->driver_path = NULL;
8374                 }
8375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8376                 if (_ptr_data_file) {
8377                         NDR_PULL_ALLOC(ndr, r->data_file);
8378                 } else {
8379                         r->data_file = NULL;
8380                 }
8381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8382                 if (_ptr_config_file) {
8383                         NDR_PULL_ALLOC(ndr, r->config_file);
8384                 } else {
8385                         r->config_file = NULL;
8386                 }
8387                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8388         }
8389         if (ndr_flags & NDR_BUFFERS) {
8390                 if (r->driver_name) {
8391                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8392                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8393                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8394                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8395                         size_driver_name_1 = ndr_get_array_size(ndr, &r->driver_name);
8396                         length_driver_name_1 = ndr_get_array_length(ndr, &r->driver_name);
8397                         if (length_driver_name_1 > size_driver_name_1) {
8398                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_name_1, length_driver_name_1);
8399                         }
8400                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_name_1, sizeof(uint16_t)));
8401                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, length_driver_name_1, sizeof(uint16_t), CH_UTF16));
8402                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8403                 }
8404                 if (r->architecture) {
8405                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8406                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8407                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8408                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8409                         size_architecture_1 = ndr_get_array_size(ndr, &r->architecture);
8410                         length_architecture_1 = ndr_get_array_length(ndr, &r->architecture);
8411                         if (length_architecture_1 > size_architecture_1) {
8412                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
8413                         }
8414                         NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
8415                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
8416                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8417                 }
8418                 if (r->driver_path) {
8419                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8420                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8421                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8422                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8423                         size_driver_path_1 = ndr_get_array_size(ndr, &r->driver_path);
8424                         length_driver_path_1 = ndr_get_array_length(ndr, &r->driver_path);
8425                         if (length_driver_path_1 > size_driver_path_1) {
8426                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_path_1, length_driver_path_1);
8427                         }
8428                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_path_1, sizeof(uint16_t)));
8429                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, length_driver_path_1, sizeof(uint16_t), CH_UTF16));
8430                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8431                 }
8432                 if (r->data_file) {
8433                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8434                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8435                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8436                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8437                         size_data_file_1 = ndr_get_array_size(ndr, &r->data_file);
8438                         length_data_file_1 = ndr_get_array_length(ndr, &r->data_file);
8439                         if (length_data_file_1 > size_data_file_1) {
8440                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_file_1, length_data_file_1);
8441                         }
8442                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_file_1, sizeof(uint16_t)));
8443                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, length_data_file_1, sizeof(uint16_t), CH_UTF16));
8444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8445                 }
8446                 if (r->config_file) {
8447                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8448                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8449                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8450                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8451                         size_config_file_1 = ndr_get_array_size(ndr, &r->config_file);
8452                         length_config_file_1 = ndr_get_array_length(ndr, &r->config_file);
8453                         if (length_config_file_1 > size_config_file_1) {
8454                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_config_file_1, length_config_file_1);
8455                         }
8456                         NDR_CHECK(ndr_check_string_terminator(ndr, length_config_file_1, sizeof(uint16_t)));
8457                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, length_config_file_1, sizeof(uint16_t), CH_UTF16));
8458                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8459                 }
8460         }
8461         return NDR_ERR_SUCCESS;
8462 }
8463
8464 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8465 {
8466         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8467         ndr->depth++;
8468         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8469         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8470         ndr->depth++;
8471         if (r->driver_name) {
8472                 ndr_print_string(ndr, "driver_name", r->driver_name);
8473         }
8474         ndr->depth--;
8475         ndr_print_ptr(ndr, "architecture", r->architecture);
8476         ndr->depth++;
8477         if (r->architecture) {
8478                 ndr_print_string(ndr, "architecture", r->architecture);
8479         }
8480         ndr->depth--;
8481         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8482         ndr->depth++;
8483         if (r->driver_path) {
8484                 ndr_print_string(ndr, "driver_path", r->driver_path);
8485         }
8486         ndr->depth--;
8487         ndr_print_ptr(ndr, "data_file", r->data_file);
8488         ndr->depth++;
8489         if (r->data_file) {
8490                 ndr_print_string(ndr, "data_file", r->data_file);
8491         }
8492         ndr->depth--;
8493         ndr_print_ptr(ndr, "config_file", r->config_file);
8494         ndr->depth++;
8495         if (r->config_file) {
8496                 ndr_print_string(ndr, "config_file", r->config_file);
8497         }
8498         ndr->depth--;
8499         ndr->depth--;
8500 }
8501
8502 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8503 {
8504         if (ndr_flags & NDR_SCALARS) {
8505                 NDR_CHECK(ndr_push_align(ndr, 5));
8506                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8508                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8509                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8510                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8517                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8518         }
8519         if (ndr_flags & NDR_BUFFERS) {
8520                 if (r->driver_name) {
8521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8524                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8525                 }
8526                 if (r->architecture) {
8527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8530                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8531                 }
8532                 if (r->driver_path) {
8533                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8535                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8536                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8537                 }
8538                 if (r->data_file) {
8539                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8542                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8543                 }
8544                 if (r->config_file) {
8545                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8547                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8548                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8549                 }
8550                 if (r->help_file) {
8551                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8552                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8553                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8554                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8555                 }
8556                 if (r->monitor_name) {
8557                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8559                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8560                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8561                 }
8562                 if (r->default_datatype) {
8563                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8564                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8565                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8566                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8567                 }
8568                 if (r->dependent_files) {
8569                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8570                 }
8571         }
8572         return NDR_ERR_SUCCESS;
8573 }
8574
8575 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8576 {
8577         uint32_t _ptr_driver_name;
8578         uint32_t size_driver_name_1 = 0;
8579         uint32_t length_driver_name_1 = 0;
8580         TALLOC_CTX *_mem_save_driver_name_0;
8581         uint32_t _ptr_architecture;
8582         uint32_t size_architecture_1 = 0;
8583         uint32_t length_architecture_1 = 0;
8584         TALLOC_CTX *_mem_save_architecture_0;
8585         uint32_t _ptr_driver_path;
8586         uint32_t size_driver_path_1 = 0;
8587         uint32_t length_driver_path_1 = 0;
8588         TALLOC_CTX *_mem_save_driver_path_0;
8589         uint32_t _ptr_data_file;
8590         uint32_t size_data_file_1 = 0;
8591         uint32_t length_data_file_1 = 0;
8592         TALLOC_CTX *_mem_save_data_file_0;
8593         uint32_t _ptr_config_file;
8594         uint32_t size_config_file_1 = 0;
8595         uint32_t length_config_file_1 = 0;
8596         TALLOC_CTX *_mem_save_config_file_0;
8597         uint32_t _ptr_help_file;
8598         uint32_t size_help_file_1 = 0;
8599         uint32_t length_help_file_1 = 0;
8600         TALLOC_CTX *_mem_save_help_file_0;
8601         uint32_t _ptr_monitor_name;
8602         uint32_t size_monitor_name_1 = 0;
8603         uint32_t length_monitor_name_1 = 0;
8604         TALLOC_CTX *_mem_save_monitor_name_0;
8605         uint32_t _ptr_default_datatype;
8606         uint32_t size_default_datatype_1 = 0;
8607         uint32_t length_default_datatype_1 = 0;
8608         TALLOC_CTX *_mem_save_default_datatype_0;
8609         uint32_t _ptr_dependent_files;
8610         TALLOC_CTX *_mem_save_dependent_files_0;
8611         if (ndr_flags & NDR_SCALARS) {
8612                 NDR_CHECK(ndr_pull_align(ndr, 5));
8613                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8614                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8615                 if (_ptr_driver_name) {
8616                         NDR_PULL_ALLOC(ndr, r->driver_name);
8617                 } else {
8618                         r->driver_name = NULL;
8619                 }
8620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8621                 if (_ptr_architecture) {
8622                         NDR_PULL_ALLOC(ndr, r->architecture);
8623                 } else {
8624                         r->architecture = NULL;
8625                 }
8626                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8627                 if (_ptr_driver_path) {
8628                         NDR_PULL_ALLOC(ndr, r->driver_path);
8629                 } else {
8630                         r->driver_path = NULL;
8631                 }
8632                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8633                 if (_ptr_data_file) {
8634                         NDR_PULL_ALLOC(ndr, r->data_file);
8635                 } else {
8636                         r->data_file = NULL;
8637                 }
8638                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8639                 if (_ptr_config_file) {
8640                         NDR_PULL_ALLOC(ndr, r->config_file);
8641                 } else {
8642                         r->config_file = NULL;
8643                 }
8644                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8645                 if (_ptr_help_file) {
8646                         NDR_PULL_ALLOC(ndr, r->help_file);
8647                 } else {
8648                         r->help_file = NULL;
8649                 }
8650                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8651                 if (_ptr_monitor_name) {
8652                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8653                 } else {
8654                         r->monitor_name = NULL;
8655                 }
8656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8657                 if (_ptr_default_datatype) {
8658                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8659                 } else {
8660                         r->default_datatype = NULL;
8661                 }
8662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8664                 if (_ptr_dependent_files) {
8665                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8666                 } else {
8667                         r->dependent_files = NULL;
8668                 }
8669                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8670         }
8671         if (ndr_flags & NDR_BUFFERS) {
8672                 if (r->driver_name) {
8673                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8674                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8675                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8676                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8677                         size_driver_name_1 = ndr_get_array_size(ndr, &r->driver_name);
8678                         length_driver_name_1 = ndr_get_array_length(ndr, &r->driver_name);
8679                         if (length_driver_name_1 > size_driver_name_1) {
8680                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_name_1, length_driver_name_1);
8681                         }
8682                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_name_1, sizeof(uint16_t)));
8683                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, length_driver_name_1, sizeof(uint16_t), CH_UTF16));
8684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8685                 }
8686                 if (r->architecture) {
8687                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8688                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8691                         size_architecture_1 = ndr_get_array_size(ndr, &r->architecture);
8692                         length_architecture_1 = ndr_get_array_length(ndr, &r->architecture);
8693                         if (length_architecture_1 > size_architecture_1) {
8694                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
8695                         }
8696                         NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
8697                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
8698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8699                 }
8700                 if (r->driver_path) {
8701                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8702                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8703                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8704                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8705                         size_driver_path_1 = ndr_get_array_size(ndr, &r->driver_path);
8706                         length_driver_path_1 = ndr_get_array_length(ndr, &r->driver_path);
8707                         if (length_driver_path_1 > size_driver_path_1) {
8708                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_path_1, length_driver_path_1);
8709                         }
8710                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_path_1, sizeof(uint16_t)));
8711                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, length_driver_path_1, sizeof(uint16_t), CH_UTF16));
8712                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8713                 }
8714                 if (r->data_file) {
8715                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8716                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8718                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8719                         size_data_file_1 = ndr_get_array_size(ndr, &r->data_file);
8720                         length_data_file_1 = ndr_get_array_length(ndr, &r->data_file);
8721                         if (length_data_file_1 > size_data_file_1) {
8722                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_file_1, length_data_file_1);
8723                         }
8724                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_file_1, sizeof(uint16_t)));
8725                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, length_data_file_1, sizeof(uint16_t), CH_UTF16));
8726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8727                 }
8728                 if (r->config_file) {
8729                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8730                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8731                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8732                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8733                         size_config_file_1 = ndr_get_array_size(ndr, &r->config_file);
8734                         length_config_file_1 = ndr_get_array_length(ndr, &r->config_file);
8735                         if (length_config_file_1 > size_config_file_1) {
8736                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_config_file_1, length_config_file_1);
8737                         }
8738                         NDR_CHECK(ndr_check_string_terminator(ndr, length_config_file_1, sizeof(uint16_t)));
8739                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, length_config_file_1, sizeof(uint16_t), CH_UTF16));
8740                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8741                 }
8742                 if (r->help_file) {
8743                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8744                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8745                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8746                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8747                         size_help_file_1 = ndr_get_array_size(ndr, &r->help_file);
8748                         length_help_file_1 = ndr_get_array_length(ndr, &r->help_file);
8749                         if (length_help_file_1 > size_help_file_1) {
8750                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_help_file_1, length_help_file_1);
8751                         }
8752                         NDR_CHECK(ndr_check_string_terminator(ndr, length_help_file_1, sizeof(uint16_t)));
8753                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, length_help_file_1, sizeof(uint16_t), CH_UTF16));
8754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8755                 }
8756                 if (r->monitor_name) {
8757                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8758                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8759                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8760                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8761                         size_monitor_name_1 = ndr_get_array_size(ndr, &r->monitor_name);
8762                         length_monitor_name_1 = ndr_get_array_length(ndr, &r->monitor_name);
8763                         if (length_monitor_name_1 > size_monitor_name_1) {
8764                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_monitor_name_1, length_monitor_name_1);
8765                         }
8766                         NDR_CHECK(ndr_check_string_terminator(ndr, length_monitor_name_1, sizeof(uint16_t)));
8767                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, length_monitor_name_1, sizeof(uint16_t), CH_UTF16));
8768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8769                 }
8770                 if (r->default_datatype) {
8771                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8772                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8775                         size_default_datatype_1 = ndr_get_array_size(ndr, &r->default_datatype);
8776                         length_default_datatype_1 = ndr_get_array_length(ndr, &r->default_datatype);
8777                         if (length_default_datatype_1 > size_default_datatype_1) {
8778                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_default_datatype_1, length_default_datatype_1);
8779                         }
8780                         NDR_CHECK(ndr_check_string_terminator(ndr, length_default_datatype_1, sizeof(uint16_t)));
8781                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, length_default_datatype_1, sizeof(uint16_t), CH_UTF16));
8782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8783                 }
8784                 if (r->dependent_files) {
8785                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8786                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8787                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8789                 }
8790         }
8791         return NDR_ERR_SUCCESS;
8792 }
8793
8794 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8795 {
8796         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8797         ndr->depth++;
8798         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8799         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8800         ndr->depth++;
8801         if (r->driver_name) {
8802                 ndr_print_string(ndr, "driver_name", r->driver_name);
8803         }
8804         ndr->depth--;
8805         ndr_print_ptr(ndr, "architecture", r->architecture);
8806         ndr->depth++;
8807         if (r->architecture) {
8808                 ndr_print_string(ndr, "architecture", r->architecture);
8809         }
8810         ndr->depth--;
8811         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8812         ndr->depth++;
8813         if (r->driver_path) {
8814                 ndr_print_string(ndr, "driver_path", r->driver_path);
8815         }
8816         ndr->depth--;
8817         ndr_print_ptr(ndr, "data_file", r->data_file);
8818         ndr->depth++;
8819         if (r->data_file) {
8820                 ndr_print_string(ndr, "data_file", r->data_file);
8821         }
8822         ndr->depth--;
8823         ndr_print_ptr(ndr, "config_file", r->config_file);
8824         ndr->depth++;
8825         if (r->config_file) {
8826                 ndr_print_string(ndr, "config_file", r->config_file);
8827         }
8828         ndr->depth--;
8829         ndr_print_ptr(ndr, "help_file", r->help_file);
8830         ndr->depth++;
8831         if (r->help_file) {
8832                 ndr_print_string(ndr, "help_file", r->help_file);
8833         }
8834         ndr->depth--;
8835         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8836         ndr->depth++;
8837         if (r->monitor_name) {
8838                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8839         }
8840         ndr->depth--;
8841         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8842         ndr->depth++;
8843         if (r->default_datatype) {
8844                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8845         }
8846         ndr->depth--;
8847         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);
8848         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8849         ndr->depth++;
8850         if (r->dependent_files) {
8851                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8852         }
8853         ndr->depth--;
8854         ndr->depth--;
8855 }
8856
8857 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8858 {
8859         if (ndr_flags & NDR_SCALARS) {
8860                 NDR_CHECK(ndr_push_align(ndr, 5));
8861                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8865                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8866                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8867                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8871                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8873                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8874                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8875         }
8876         if (ndr_flags & NDR_BUFFERS) {
8877                 if (r->driver_name) {
8878                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8879                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8880                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8881                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8882                 }
8883                 if (r->architecture) {
8884                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8885                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8886                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8887                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8888                 }
8889                 if (r->driver_path) {
8890                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8891                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8892                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8893                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8894                 }
8895                 if (r->data_file) {
8896                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8897                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8898                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8899                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8900                 }
8901                 if (r->config_file) {
8902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8903                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8905                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8906                 }
8907                 if (r->help_file) {
8908                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8909                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8910                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8911                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8912                 }
8913                 if (r->monitor_name) {
8914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8915                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8917                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8918                 }
8919                 if (r->default_datatype) {
8920                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8921                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8922                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8923                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8924                 }
8925                 if (r->dependent_files) {
8926                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8927                 }
8928                 if (r->previous_names) {
8929                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8930                 }
8931         }
8932         return NDR_ERR_SUCCESS;
8933 }
8934
8935 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8936 {
8937         uint32_t _ptr_driver_name;
8938         uint32_t size_driver_name_1 = 0;
8939         uint32_t length_driver_name_1 = 0;
8940         TALLOC_CTX *_mem_save_driver_name_0;
8941         uint32_t _ptr_architecture;
8942         uint32_t size_architecture_1 = 0;
8943         uint32_t length_architecture_1 = 0;
8944         TALLOC_CTX *_mem_save_architecture_0;
8945         uint32_t _ptr_driver_path;
8946         uint32_t size_driver_path_1 = 0;
8947         uint32_t length_driver_path_1 = 0;
8948         TALLOC_CTX *_mem_save_driver_path_0;
8949         uint32_t _ptr_data_file;
8950         uint32_t size_data_file_1 = 0;
8951         uint32_t length_data_file_1 = 0;
8952         TALLOC_CTX *_mem_save_data_file_0;
8953         uint32_t _ptr_config_file;
8954         uint32_t size_config_file_1 = 0;
8955         uint32_t length_config_file_1 = 0;
8956         TALLOC_CTX *_mem_save_config_file_0;
8957         uint32_t _ptr_help_file;
8958         uint32_t size_help_file_1 = 0;
8959         uint32_t length_help_file_1 = 0;
8960         TALLOC_CTX *_mem_save_help_file_0;
8961         uint32_t _ptr_monitor_name;
8962         uint32_t size_monitor_name_1 = 0;
8963         uint32_t length_monitor_name_1 = 0;
8964         TALLOC_CTX *_mem_save_monitor_name_0;
8965         uint32_t _ptr_default_datatype;
8966         uint32_t size_default_datatype_1 = 0;
8967         uint32_t length_default_datatype_1 = 0;
8968         TALLOC_CTX *_mem_save_default_datatype_0;
8969         uint32_t _ptr_dependent_files;
8970         TALLOC_CTX *_mem_save_dependent_files_0;
8971         uint32_t _ptr_previous_names;
8972         TALLOC_CTX *_mem_save_previous_names_0;
8973         if (ndr_flags & NDR_SCALARS) {
8974                 NDR_CHECK(ndr_pull_align(ndr, 5));
8975                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8976                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8977                 if (_ptr_driver_name) {
8978                         NDR_PULL_ALLOC(ndr, r->driver_name);
8979                 } else {
8980                         r->driver_name = NULL;
8981                 }
8982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8983                 if (_ptr_architecture) {
8984                         NDR_PULL_ALLOC(ndr, r->architecture);
8985                 } else {
8986                         r->architecture = NULL;
8987                 }
8988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8989                 if (_ptr_driver_path) {
8990                         NDR_PULL_ALLOC(ndr, r->driver_path);
8991                 } else {
8992                         r->driver_path = NULL;
8993                 }
8994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8995                 if (_ptr_data_file) {
8996                         NDR_PULL_ALLOC(ndr, r->data_file);
8997                 } else {
8998                         r->data_file = NULL;
8999                 }
9000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9001                 if (_ptr_config_file) {
9002                         NDR_PULL_ALLOC(ndr, r->config_file);
9003                 } else {
9004                         r->config_file = NULL;
9005                 }
9006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9007                 if (_ptr_help_file) {
9008                         NDR_PULL_ALLOC(ndr, r->help_file);
9009                 } else {
9010                         r->help_file = NULL;
9011                 }
9012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9013                 if (_ptr_monitor_name) {
9014                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9015                 } else {
9016                         r->monitor_name = NULL;
9017                 }
9018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9019                 if (_ptr_default_datatype) {
9020                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9021                 } else {
9022                         r->default_datatype = NULL;
9023                 }
9024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9026                 if (_ptr_dependent_files) {
9027                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9028                 } else {
9029                         r->dependent_files = NULL;
9030                 }
9031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9033                 if (_ptr_previous_names) {
9034                         NDR_PULL_ALLOC(ndr, r->previous_names);
9035                 } else {
9036                         r->previous_names = NULL;
9037                 }
9038                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9039         }
9040         if (ndr_flags & NDR_BUFFERS) {
9041                 if (r->driver_name) {
9042                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9043                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9044                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9045                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9046                         size_driver_name_1 = ndr_get_array_size(ndr, &r->driver_name);
9047                         length_driver_name_1 = ndr_get_array_length(ndr, &r->driver_name);
9048                         if (length_driver_name_1 > size_driver_name_1) {
9049                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_name_1, length_driver_name_1);
9050                         }
9051                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_name_1, sizeof(uint16_t)));
9052                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, length_driver_name_1, sizeof(uint16_t), CH_UTF16));
9053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9054                 }
9055                 if (r->architecture) {
9056                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9057                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9058                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9059                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9060                         size_architecture_1 = ndr_get_array_size(ndr, &r->architecture);
9061                         length_architecture_1 = ndr_get_array_length(ndr, &r->architecture);
9062                         if (length_architecture_1 > size_architecture_1) {
9063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
9064                         }
9065                         NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
9066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
9067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9068                 }
9069                 if (r->driver_path) {
9070                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9071                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9074                         size_driver_path_1 = ndr_get_array_size(ndr, &r->driver_path);
9075                         length_driver_path_1 = ndr_get_array_length(ndr, &r->driver_path);
9076                         if (length_driver_path_1 > size_driver_path_1) {
9077                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_path_1, length_driver_path_1);
9078                         }
9079                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_path_1, sizeof(uint16_t)));
9080                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, length_driver_path_1, sizeof(uint16_t), CH_UTF16));
9081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9082                 }
9083                 if (r->data_file) {
9084                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9085                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9086                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9087                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9088                         size_data_file_1 = ndr_get_array_size(ndr, &r->data_file);
9089                         length_data_file_1 = ndr_get_array_length(ndr, &r->data_file);
9090                         if (length_data_file_1 > size_data_file_1) {
9091                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_file_1, length_data_file_1);
9092                         }
9093                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_file_1, sizeof(uint16_t)));
9094                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, length_data_file_1, sizeof(uint16_t), CH_UTF16));
9095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9096                 }
9097                 if (r->config_file) {
9098                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9099                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9102                         size_config_file_1 = ndr_get_array_size(ndr, &r->config_file);
9103                         length_config_file_1 = ndr_get_array_length(ndr, &r->config_file);
9104                         if (length_config_file_1 > size_config_file_1) {
9105                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_config_file_1, length_config_file_1);
9106                         }
9107                         NDR_CHECK(ndr_check_string_terminator(ndr, length_config_file_1, sizeof(uint16_t)));
9108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, length_config_file_1, sizeof(uint16_t), CH_UTF16));
9109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9110                 }
9111                 if (r->help_file) {
9112                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9113                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9115                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9116                         size_help_file_1 = ndr_get_array_size(ndr, &r->help_file);
9117                         length_help_file_1 = ndr_get_array_length(ndr, &r->help_file);
9118                         if (length_help_file_1 > size_help_file_1) {
9119                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_help_file_1, length_help_file_1);
9120                         }
9121                         NDR_CHECK(ndr_check_string_terminator(ndr, length_help_file_1, sizeof(uint16_t)));
9122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, length_help_file_1, sizeof(uint16_t), CH_UTF16));
9123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9124                 }
9125                 if (r->monitor_name) {
9126                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9127                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9130                         size_monitor_name_1 = ndr_get_array_size(ndr, &r->monitor_name);
9131                         length_monitor_name_1 = ndr_get_array_length(ndr, &r->monitor_name);
9132                         if (length_monitor_name_1 > size_monitor_name_1) {
9133                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_monitor_name_1, length_monitor_name_1);
9134                         }
9135                         NDR_CHECK(ndr_check_string_terminator(ndr, length_monitor_name_1, sizeof(uint16_t)));
9136                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, length_monitor_name_1, sizeof(uint16_t), CH_UTF16));
9137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9138                 }
9139                 if (r->default_datatype) {
9140                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9141                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9142                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9143                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9144                         size_default_datatype_1 = ndr_get_array_size(ndr, &r->default_datatype);
9145                         length_default_datatype_1 = ndr_get_array_length(ndr, &r->default_datatype);
9146                         if (length_default_datatype_1 > size_default_datatype_1) {
9147                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_default_datatype_1, length_default_datatype_1);
9148                         }
9149                         NDR_CHECK(ndr_check_string_terminator(ndr, length_default_datatype_1, sizeof(uint16_t)));
9150                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, length_default_datatype_1, sizeof(uint16_t), CH_UTF16));
9151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9152                 }
9153                 if (r->dependent_files) {
9154                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9155                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9156                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9158                 }
9159                 if (r->previous_names) {
9160                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9161                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9162                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9163                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9164                 }
9165         }
9166         return NDR_ERR_SUCCESS;
9167 }
9168
9169 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9170 {
9171         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9172         ndr->depth++;
9173         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9174         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9175         ndr->depth++;
9176         if (r->driver_name) {
9177                 ndr_print_string(ndr, "driver_name", r->driver_name);
9178         }
9179         ndr->depth--;
9180         ndr_print_ptr(ndr, "architecture", r->architecture);
9181         ndr->depth++;
9182         if (r->architecture) {
9183                 ndr_print_string(ndr, "architecture", r->architecture);
9184         }
9185         ndr->depth--;
9186         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9187         ndr->depth++;
9188         if (r->driver_path) {
9189                 ndr_print_string(ndr, "driver_path", r->driver_path);
9190         }
9191         ndr->depth--;
9192         ndr_print_ptr(ndr, "data_file", r->data_file);
9193         ndr->depth++;
9194         if (r->data_file) {
9195                 ndr_print_string(ndr, "data_file", r->data_file);
9196         }
9197         ndr->depth--;
9198         ndr_print_ptr(ndr, "config_file", r->config_file);
9199         ndr->depth++;
9200         if (r->config_file) {
9201                 ndr_print_string(ndr, "config_file", r->config_file);
9202         }
9203         ndr->depth--;
9204         ndr_print_ptr(ndr, "help_file", r->help_file);
9205         ndr->depth++;
9206         if (r->help_file) {
9207                 ndr_print_string(ndr, "help_file", r->help_file);
9208         }
9209         ndr->depth--;
9210         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9211         ndr->depth++;
9212         if (r->monitor_name) {
9213                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9214         }
9215         ndr->depth--;
9216         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9217         ndr->depth++;
9218         if (r->default_datatype) {
9219                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9220         }
9221         ndr->depth--;
9222         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);
9223         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9224         ndr->depth++;
9225         if (r->dependent_files) {
9226                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9227         }
9228         ndr->depth--;
9229         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);
9230         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9231         ndr->depth++;
9232         if (r->previous_names) {
9233                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9234         }
9235         ndr->depth--;
9236         ndr->depth--;
9237 }
9238
9239 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9240 {
9241         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9242         return NDR_ERR_SUCCESS;
9243 }
9244
9245 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9246 {
9247         uint32_t v;
9248         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9249         *r = v;
9250         return NDR_ERR_SUCCESS;
9251 }
9252
9253 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9254 {
9255         ndr_print_uint32(ndr, name, r);
9256         ndr->depth++;
9257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9258         ndr->depth--;
9259 }
9260
9261 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9262 {
9263         if (ndr_flags & NDR_SCALARS) {
9264                 NDR_CHECK(ndr_push_align(ndr, 8));
9265                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9266                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9267                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9268                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9270                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9272                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9275                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9277                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9278                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9279                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9280                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9281                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9284                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9285         }
9286         if (ndr_flags & NDR_BUFFERS) {
9287                 if (r->driver_name) {
9288                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9291                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9292                 }
9293                 if (r->architecture) {
9294                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9295                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9297                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9298                 }
9299                 if (r->driver_path) {
9300                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9301                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9302                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9303                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9304                 }
9305                 if (r->data_file) {
9306                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9307                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9308                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9309                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9310                 }
9311                 if (r->config_file) {
9312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9313                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9314                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9315                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9316                 }
9317                 if (r->help_file) {
9318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9319                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9320                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9321                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9322                 }
9323                 if (r->monitor_name) {
9324                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9325                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9326                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9327                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9328                 }
9329                 if (r->default_datatype) {
9330                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9331                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9332                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9333                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9334                 }
9335                 if (r->dependent_files) {
9336                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9337                 }
9338                 if (r->previous_names) {
9339                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9340                 }
9341                 if (r->manufacturer_name) {
9342                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9343                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9344                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9345                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9346                 }
9347                 if (r->manufacturer_url) {
9348                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9349                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9350                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9351                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9352                 }
9353                 if (r->hardware_id) {
9354                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9355                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9356                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9357                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9358                 }
9359                 if (r->provider) {
9360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9362                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9363                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9364                 }
9365         }
9366         return NDR_ERR_SUCCESS;
9367 }
9368
9369 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9370 {
9371         uint32_t _ptr_driver_name;
9372         uint32_t size_driver_name_1 = 0;
9373         uint32_t length_driver_name_1 = 0;
9374         TALLOC_CTX *_mem_save_driver_name_0;
9375         uint32_t _ptr_architecture;
9376         uint32_t size_architecture_1 = 0;
9377         uint32_t length_architecture_1 = 0;
9378         TALLOC_CTX *_mem_save_architecture_0;
9379         uint32_t _ptr_driver_path;
9380         uint32_t size_driver_path_1 = 0;
9381         uint32_t length_driver_path_1 = 0;
9382         TALLOC_CTX *_mem_save_driver_path_0;
9383         uint32_t _ptr_data_file;
9384         uint32_t size_data_file_1 = 0;
9385         uint32_t length_data_file_1 = 0;
9386         TALLOC_CTX *_mem_save_data_file_0;
9387         uint32_t _ptr_config_file;
9388         uint32_t size_config_file_1 = 0;
9389         uint32_t length_config_file_1 = 0;
9390         TALLOC_CTX *_mem_save_config_file_0;
9391         uint32_t _ptr_help_file;
9392         uint32_t size_help_file_1 = 0;
9393         uint32_t length_help_file_1 = 0;
9394         TALLOC_CTX *_mem_save_help_file_0;
9395         uint32_t _ptr_monitor_name;
9396         uint32_t size_monitor_name_1 = 0;
9397         uint32_t length_monitor_name_1 = 0;
9398         TALLOC_CTX *_mem_save_monitor_name_0;
9399         uint32_t _ptr_default_datatype;
9400         uint32_t size_default_datatype_1 = 0;
9401         uint32_t length_default_datatype_1 = 0;
9402         TALLOC_CTX *_mem_save_default_datatype_0;
9403         uint32_t _ptr_dependent_files;
9404         TALLOC_CTX *_mem_save_dependent_files_0;
9405         uint32_t _ptr_previous_names;
9406         TALLOC_CTX *_mem_save_previous_names_0;
9407         uint32_t _ptr_manufacturer_name;
9408         uint32_t size_manufacturer_name_1 = 0;
9409         uint32_t length_manufacturer_name_1 = 0;
9410         TALLOC_CTX *_mem_save_manufacturer_name_0;
9411         uint32_t _ptr_manufacturer_url;
9412         uint32_t size_manufacturer_url_1 = 0;
9413         uint32_t length_manufacturer_url_1 = 0;
9414         TALLOC_CTX *_mem_save_manufacturer_url_0;
9415         uint32_t _ptr_hardware_id;
9416         uint32_t size_hardware_id_1 = 0;
9417         uint32_t length_hardware_id_1 = 0;
9418         TALLOC_CTX *_mem_save_hardware_id_0;
9419         uint32_t _ptr_provider;
9420         uint32_t size_provider_1 = 0;
9421         uint32_t length_provider_1 = 0;
9422         TALLOC_CTX *_mem_save_provider_0;
9423         if (ndr_flags & NDR_SCALARS) {
9424                 NDR_CHECK(ndr_pull_align(ndr, 8));
9425                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9427                 if (_ptr_driver_name) {
9428                         NDR_PULL_ALLOC(ndr, r->driver_name);
9429                 } else {
9430                         r->driver_name = NULL;
9431                 }
9432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9433                 if (_ptr_architecture) {
9434                         NDR_PULL_ALLOC(ndr, r->architecture);
9435                 } else {
9436                         r->architecture = NULL;
9437                 }
9438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9439                 if (_ptr_driver_path) {
9440                         NDR_PULL_ALLOC(ndr, r->driver_path);
9441                 } else {
9442                         r->driver_path = NULL;
9443                 }
9444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9445                 if (_ptr_data_file) {
9446                         NDR_PULL_ALLOC(ndr, r->data_file);
9447                 } else {
9448                         r->data_file = NULL;
9449                 }
9450                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9451                 if (_ptr_config_file) {
9452                         NDR_PULL_ALLOC(ndr, r->config_file);
9453                 } else {
9454                         r->config_file = NULL;
9455                 }
9456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9457                 if (_ptr_help_file) {
9458                         NDR_PULL_ALLOC(ndr, r->help_file);
9459                 } else {
9460                         r->help_file = NULL;
9461                 }
9462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9463                 if (_ptr_monitor_name) {
9464                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9465                 } else {
9466                         r->monitor_name = NULL;
9467                 }
9468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9469                 if (_ptr_default_datatype) {
9470                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9471                 } else {
9472                         r->default_datatype = NULL;
9473                 }
9474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9476                 if (_ptr_dependent_files) {
9477                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9478                 } else {
9479                         r->dependent_files = NULL;
9480                 }
9481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9483                 if (_ptr_previous_names) {
9484                         NDR_PULL_ALLOC(ndr, r->previous_names);
9485                 } else {
9486                         r->previous_names = NULL;
9487                 }
9488                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9489                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9491                 if (_ptr_manufacturer_name) {
9492                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9493                 } else {
9494                         r->manufacturer_name = NULL;
9495                 }
9496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9497                 if (_ptr_manufacturer_url) {
9498                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9499                 } else {
9500                         r->manufacturer_url = NULL;
9501                 }
9502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9503                 if (_ptr_hardware_id) {
9504                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9505                 } else {
9506                         r->hardware_id = NULL;
9507                 }
9508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9509                 if (_ptr_provider) {
9510                         NDR_PULL_ALLOC(ndr, r->provider);
9511                 } else {
9512                         r->provider = NULL;
9513                 }
9514                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9515         }
9516         if (ndr_flags & NDR_BUFFERS) {
9517                 if (r->driver_name) {
9518                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9519                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9520                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9521                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9522                         size_driver_name_1 = ndr_get_array_size(ndr, &r->driver_name);
9523                         length_driver_name_1 = ndr_get_array_length(ndr, &r->driver_name);
9524                         if (length_driver_name_1 > size_driver_name_1) {
9525                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_name_1, length_driver_name_1);
9526                         }
9527                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_name_1, sizeof(uint16_t)));
9528                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, length_driver_name_1, sizeof(uint16_t), CH_UTF16));
9529                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9530                 }
9531                 if (r->architecture) {
9532                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9533                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9534                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9535                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9536                         size_architecture_1 = ndr_get_array_size(ndr, &r->architecture);
9537                         length_architecture_1 = ndr_get_array_length(ndr, &r->architecture);
9538                         if (length_architecture_1 > size_architecture_1) {
9539                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
9540                         }
9541                         NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
9542                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
9543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9544                 }
9545                 if (r->driver_path) {
9546                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9547                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9548                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9549                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9550                         size_driver_path_1 = ndr_get_array_size(ndr, &r->driver_path);
9551                         length_driver_path_1 = ndr_get_array_length(ndr, &r->driver_path);
9552                         if (length_driver_path_1 > size_driver_path_1) {
9553                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_path_1, length_driver_path_1);
9554                         }
9555                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_path_1, sizeof(uint16_t)));
9556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, length_driver_path_1, sizeof(uint16_t), CH_UTF16));
9557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9558                 }
9559                 if (r->data_file) {
9560                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9561                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9564                         size_data_file_1 = ndr_get_array_size(ndr, &r->data_file);
9565                         length_data_file_1 = ndr_get_array_length(ndr, &r->data_file);
9566                         if (length_data_file_1 > size_data_file_1) {
9567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_file_1, length_data_file_1);
9568                         }
9569                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_file_1, sizeof(uint16_t)));
9570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, length_data_file_1, sizeof(uint16_t), CH_UTF16));
9571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9572                 }
9573                 if (r->config_file) {
9574                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9575                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9576                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9577                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9578                         size_config_file_1 = ndr_get_array_size(ndr, &r->config_file);
9579                         length_config_file_1 = ndr_get_array_length(ndr, &r->config_file);
9580                         if (length_config_file_1 > size_config_file_1) {
9581                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_config_file_1, length_config_file_1);
9582                         }
9583                         NDR_CHECK(ndr_check_string_terminator(ndr, length_config_file_1, sizeof(uint16_t)));
9584                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, length_config_file_1, sizeof(uint16_t), CH_UTF16));
9585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9586                 }
9587                 if (r->help_file) {
9588                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9589                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9590                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9591                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9592                         size_help_file_1 = ndr_get_array_size(ndr, &r->help_file);
9593                         length_help_file_1 = ndr_get_array_length(ndr, &r->help_file);
9594                         if (length_help_file_1 > size_help_file_1) {
9595                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_help_file_1, length_help_file_1);
9596                         }
9597                         NDR_CHECK(ndr_check_string_terminator(ndr, length_help_file_1, sizeof(uint16_t)));
9598                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, length_help_file_1, sizeof(uint16_t), CH_UTF16));
9599                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9600                 }
9601                 if (r->monitor_name) {
9602                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9603                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9604                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9605                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9606                         size_monitor_name_1 = ndr_get_array_size(ndr, &r->monitor_name);
9607                         length_monitor_name_1 = ndr_get_array_length(ndr, &r->monitor_name);
9608                         if (length_monitor_name_1 > size_monitor_name_1) {
9609                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_monitor_name_1, length_monitor_name_1);
9610                         }
9611                         NDR_CHECK(ndr_check_string_terminator(ndr, length_monitor_name_1, sizeof(uint16_t)));
9612                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, length_monitor_name_1, sizeof(uint16_t), CH_UTF16));
9613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9614                 }
9615                 if (r->default_datatype) {
9616                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9617                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9620                         size_default_datatype_1 = ndr_get_array_size(ndr, &r->default_datatype);
9621                         length_default_datatype_1 = ndr_get_array_length(ndr, &r->default_datatype);
9622                         if (length_default_datatype_1 > size_default_datatype_1) {
9623                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_default_datatype_1, length_default_datatype_1);
9624                         }
9625                         NDR_CHECK(ndr_check_string_terminator(ndr, length_default_datatype_1, sizeof(uint16_t)));
9626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, length_default_datatype_1, sizeof(uint16_t), CH_UTF16));
9627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9628                 }
9629                 if (r->dependent_files) {
9630                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9631                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9632                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9634                 }
9635                 if (r->previous_names) {
9636                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9637                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9638                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9640                 }
9641                 if (r->manufacturer_name) {
9642                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9643                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9644                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9645                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9646                         size_manufacturer_name_1 = ndr_get_array_size(ndr, &r->manufacturer_name);
9647                         length_manufacturer_name_1 = ndr_get_array_length(ndr, &r->manufacturer_name);
9648                         if (length_manufacturer_name_1 > size_manufacturer_name_1) {
9649                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_manufacturer_name_1, length_manufacturer_name_1);
9650                         }
9651                         NDR_CHECK(ndr_check_string_terminator(ndr, length_manufacturer_name_1, sizeof(uint16_t)));
9652                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, length_manufacturer_name_1, sizeof(uint16_t), CH_UTF16));
9653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9654                 }
9655                 if (r->manufacturer_url) {
9656                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9657                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9658                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9659                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9660                         size_manufacturer_url_1 = ndr_get_array_size(ndr, &r->manufacturer_url);
9661                         length_manufacturer_url_1 = ndr_get_array_length(ndr, &r->manufacturer_url);
9662                         if (length_manufacturer_url_1 > size_manufacturer_url_1) {
9663                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_manufacturer_url_1, length_manufacturer_url_1);
9664                         }
9665                         NDR_CHECK(ndr_check_string_terminator(ndr, length_manufacturer_url_1, sizeof(uint16_t)));
9666                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, length_manufacturer_url_1, sizeof(uint16_t), CH_UTF16));
9667                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9668                 }
9669                 if (r->hardware_id) {
9670                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9671                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9672                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9673                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9674                         size_hardware_id_1 = ndr_get_array_size(ndr, &r->hardware_id);
9675                         length_hardware_id_1 = ndr_get_array_length(ndr, &r->hardware_id);
9676                         if (length_hardware_id_1 > size_hardware_id_1) {
9677                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_hardware_id_1, length_hardware_id_1);
9678                         }
9679                         NDR_CHECK(ndr_check_string_terminator(ndr, length_hardware_id_1, sizeof(uint16_t)));
9680                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, length_hardware_id_1, sizeof(uint16_t), CH_UTF16));
9681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9682                 }
9683                 if (r->provider) {
9684                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9685                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9686                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9687                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9688                         size_provider_1 = ndr_get_array_size(ndr, &r->provider);
9689                         length_provider_1 = ndr_get_array_length(ndr, &r->provider);
9690                         if (length_provider_1 > size_provider_1) {
9691                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_provider_1, length_provider_1);
9692                         }
9693                         NDR_CHECK(ndr_check_string_terminator(ndr, length_provider_1, sizeof(uint16_t)));
9694                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, length_provider_1, sizeof(uint16_t), CH_UTF16));
9695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9696                 }
9697         }
9698         return NDR_ERR_SUCCESS;
9699 }
9700
9701 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9702 {
9703         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9704         ndr->depth++;
9705         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9706         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9707         ndr->depth++;
9708         if (r->driver_name) {
9709                 ndr_print_string(ndr, "driver_name", r->driver_name);
9710         }
9711         ndr->depth--;
9712         ndr_print_ptr(ndr, "architecture", r->architecture);
9713         ndr->depth++;
9714         if (r->architecture) {
9715                 ndr_print_string(ndr, "architecture", r->architecture);
9716         }
9717         ndr->depth--;
9718         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9719         ndr->depth++;
9720         if (r->driver_path) {
9721                 ndr_print_string(ndr, "driver_path", r->driver_path);
9722         }
9723         ndr->depth--;
9724         ndr_print_ptr(ndr, "data_file", r->data_file);
9725         ndr->depth++;
9726         if (r->data_file) {
9727                 ndr_print_string(ndr, "data_file", r->data_file);
9728         }
9729         ndr->depth--;
9730         ndr_print_ptr(ndr, "config_file", r->config_file);
9731         ndr->depth++;
9732         if (r->config_file) {
9733                 ndr_print_string(ndr, "config_file", r->config_file);
9734         }
9735         ndr->depth--;
9736         ndr_print_ptr(ndr, "help_file", r->help_file);
9737         ndr->depth++;
9738         if (r->help_file) {
9739                 ndr_print_string(ndr, "help_file", r->help_file);
9740         }
9741         ndr->depth--;
9742         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9743         ndr->depth++;
9744         if (r->monitor_name) {
9745                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9746         }
9747         ndr->depth--;
9748         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9749         ndr->depth++;
9750         if (r->default_datatype) {
9751                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9752         }
9753         ndr->depth--;
9754         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);
9755         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9756         ndr->depth++;
9757         if (r->dependent_files) {
9758                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9759         }
9760         ndr->depth--;
9761         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);
9762         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9763         ndr->depth++;
9764         if (r->previous_names) {
9765                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9766         }
9767         ndr->depth--;
9768         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9769         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9770         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9771         ndr->depth++;
9772         if (r->manufacturer_name) {
9773                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9774         }
9775         ndr->depth--;
9776         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9777         ndr->depth++;
9778         if (r->manufacturer_url) {
9779                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9780         }
9781         ndr->depth--;
9782         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9783         ndr->depth++;
9784         if (r->hardware_id) {
9785                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9786         }
9787         ndr->depth--;
9788         ndr_print_ptr(ndr, "provider", r->provider);
9789         ndr->depth++;
9790         if (r->provider) {
9791                 ndr_print_string(ndr, "provider", r->provider);
9792         }
9793         ndr->depth--;
9794         ndr->depth--;
9795 }
9796
9797 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9798 {
9799         if (ndr_flags & NDR_SCALARS) {
9800                 NDR_CHECK(ndr_push_align(ndr, 8));
9801                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9809                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9813                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9814                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9815                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9817                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9819                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9820                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9821                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9823                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9824                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9827                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9828                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9829                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9830                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9831         }
9832         if (ndr_flags & NDR_BUFFERS) {
9833                 if (r->driver_name) {
9834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9835                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9836                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9837                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9838                 }
9839                 if (r->architecture) {
9840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9842                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9843                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9844                 }
9845                 if (r->driver_path) {
9846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9849                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9850                 }
9851                 if (r->data_file) {
9852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9856                 }
9857                 if (r->config_file) {
9858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9862                 }
9863                 if (r->help_file) {
9864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9868                 }
9869                 if (r->monitor_name) {
9870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9874                 }
9875                 if (r->default_datatype) {
9876                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9878                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9879                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9880                 }
9881                 if (r->dependent_files) {
9882                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9883                 }
9884                 if (r->previous_names) {
9885                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9886                 }
9887                 if (r->manufacturer_name) {
9888                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9889                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9890                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9891                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9892                 }
9893                 if (r->manufacturer_url) {
9894                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9895                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9896                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9897                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9898                 }
9899                 if (r->hardware_id) {
9900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9901                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9903                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9904                 }
9905                 if (r->provider) {
9906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9907                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9908                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9910                 }
9911                 if (r->print_processor) {
9912                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9913                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9915                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9916                 }
9917                 if (r->vendor_setup) {
9918                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9919                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9920                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9921                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9922                 }
9923                 if (r->color_profiles) {
9924                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9925                 }
9926                 if (r->inf_path) {
9927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9929                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9931                 }
9932                 if (r->core_driver_dependencies) {
9933                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9934                 }
9935         }
9936         return NDR_ERR_SUCCESS;
9937 }
9938
9939 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9940 {
9941         uint32_t _ptr_driver_name;
9942         uint32_t size_driver_name_1 = 0;
9943         uint32_t length_driver_name_1 = 0;
9944         TALLOC_CTX *_mem_save_driver_name_0;
9945         uint32_t _ptr_architecture;
9946         uint32_t size_architecture_1 = 0;
9947         uint32_t length_architecture_1 = 0;
9948         TALLOC_CTX *_mem_save_architecture_0;
9949         uint32_t _ptr_driver_path;
9950         uint32_t size_driver_path_1 = 0;
9951         uint32_t length_driver_path_1 = 0;
9952         TALLOC_CTX *_mem_save_driver_path_0;
9953         uint32_t _ptr_data_file;
9954         uint32_t size_data_file_1 = 0;
9955         uint32_t length_data_file_1 = 0;
9956         TALLOC_CTX *_mem_save_data_file_0;
9957         uint32_t _ptr_config_file;
9958         uint32_t size_config_file_1 = 0;
9959         uint32_t length_config_file_1 = 0;
9960         TALLOC_CTX *_mem_save_config_file_0;
9961         uint32_t _ptr_help_file;
9962         uint32_t size_help_file_1 = 0;
9963         uint32_t length_help_file_1 = 0;
9964         TALLOC_CTX *_mem_save_help_file_0;
9965         uint32_t _ptr_monitor_name;
9966         uint32_t size_monitor_name_1 = 0;
9967         uint32_t length_monitor_name_1 = 0;
9968         TALLOC_CTX *_mem_save_monitor_name_0;
9969         uint32_t _ptr_default_datatype;
9970         uint32_t size_default_datatype_1 = 0;
9971         uint32_t length_default_datatype_1 = 0;
9972         TALLOC_CTX *_mem_save_default_datatype_0;
9973         uint32_t _ptr_dependent_files;
9974         TALLOC_CTX *_mem_save_dependent_files_0;
9975         uint32_t _ptr_previous_names;
9976         TALLOC_CTX *_mem_save_previous_names_0;
9977         uint32_t _ptr_manufacturer_name;
9978         uint32_t size_manufacturer_name_1 = 0;
9979         uint32_t length_manufacturer_name_1 = 0;
9980         TALLOC_CTX *_mem_save_manufacturer_name_0;
9981         uint32_t _ptr_manufacturer_url;
9982         uint32_t size_manufacturer_url_1 = 0;
9983         uint32_t length_manufacturer_url_1 = 0;
9984         TALLOC_CTX *_mem_save_manufacturer_url_0;
9985         uint32_t _ptr_hardware_id;
9986         uint32_t size_hardware_id_1 = 0;
9987         uint32_t length_hardware_id_1 = 0;
9988         TALLOC_CTX *_mem_save_hardware_id_0;
9989         uint32_t _ptr_provider;
9990         uint32_t size_provider_1 = 0;
9991         uint32_t length_provider_1 = 0;
9992         TALLOC_CTX *_mem_save_provider_0;
9993         uint32_t _ptr_print_processor;
9994         uint32_t size_print_processor_1 = 0;
9995         uint32_t length_print_processor_1 = 0;
9996         TALLOC_CTX *_mem_save_print_processor_0;
9997         uint32_t _ptr_vendor_setup;
9998         uint32_t size_vendor_setup_1 = 0;
9999         uint32_t length_vendor_setup_1 = 0;
10000         TALLOC_CTX *_mem_save_vendor_setup_0;
10001         uint32_t _ptr_color_profiles;
10002         TALLOC_CTX *_mem_save_color_profiles_0;
10003         uint32_t _ptr_inf_path;
10004         uint32_t size_inf_path_1 = 0;
10005         uint32_t length_inf_path_1 = 0;
10006         TALLOC_CTX *_mem_save_inf_path_0;
10007         uint32_t _ptr_core_driver_dependencies;
10008         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
10009         if (ndr_flags & NDR_SCALARS) {
10010                 NDR_CHECK(ndr_pull_align(ndr, 8));
10011                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10013                 if (_ptr_driver_name) {
10014                         NDR_PULL_ALLOC(ndr, r->driver_name);
10015                 } else {
10016                         r->driver_name = NULL;
10017                 }
10018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10019                 if (_ptr_architecture) {
10020                         NDR_PULL_ALLOC(ndr, r->architecture);
10021                 } else {
10022                         r->architecture = NULL;
10023                 }
10024                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10025                 if (_ptr_driver_path) {
10026                         NDR_PULL_ALLOC(ndr, r->driver_path);
10027                 } else {
10028                         r->driver_path = NULL;
10029                 }
10030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10031                 if (_ptr_data_file) {
10032                         NDR_PULL_ALLOC(ndr, r->data_file);
10033                 } else {
10034                         r->data_file = NULL;
10035                 }
10036                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10037                 if (_ptr_config_file) {
10038                         NDR_PULL_ALLOC(ndr, r->config_file);
10039                 } else {
10040                         r->config_file = NULL;
10041                 }
10042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10043                 if (_ptr_help_file) {
10044                         NDR_PULL_ALLOC(ndr, r->help_file);
10045                 } else {
10046                         r->help_file = NULL;
10047                 }
10048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10049                 if (_ptr_monitor_name) {
10050                         NDR_PULL_ALLOC(ndr, r->monitor_name);
10051                 } else {
10052                         r->monitor_name = NULL;
10053                 }
10054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10055                 if (_ptr_default_datatype) {
10056                         NDR_PULL_ALLOC(ndr, r->default_datatype);
10057                 } else {
10058                         r->default_datatype = NULL;
10059                 }
10060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
10061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10062                 if (_ptr_dependent_files) {
10063                         NDR_PULL_ALLOC(ndr, r->dependent_files);
10064                 } else {
10065                         r->dependent_files = NULL;
10066                 }
10067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
10068                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10069                 if (_ptr_previous_names) {
10070                         NDR_PULL_ALLOC(ndr, r->previous_names);
10071                 } else {
10072                         r->previous_names = NULL;
10073                 }
10074                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
10075                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10077                 if (_ptr_manufacturer_name) {
10078                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10079                 } else {
10080                         r->manufacturer_name = NULL;
10081                 }
10082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10083                 if (_ptr_manufacturer_url) {
10084                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10085                 } else {
10086                         r->manufacturer_url = NULL;
10087                 }
10088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10089                 if (_ptr_hardware_id) {
10090                         NDR_PULL_ALLOC(ndr, r->hardware_id);
10091                 } else {
10092                         r->hardware_id = NULL;
10093                 }
10094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10095                 if (_ptr_provider) {
10096                         NDR_PULL_ALLOC(ndr, r->provider);
10097                 } else {
10098                         r->provider = NULL;
10099                 }
10100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10101                 if (_ptr_print_processor) {
10102                         NDR_PULL_ALLOC(ndr, r->print_processor);
10103                 } else {
10104                         r->print_processor = NULL;
10105                 }
10106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10107                 if (_ptr_vendor_setup) {
10108                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
10109                 } else {
10110                         r->vendor_setup = NULL;
10111                 }
10112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
10113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10114                 if (_ptr_color_profiles) {
10115                         NDR_PULL_ALLOC(ndr, r->color_profiles);
10116                 } else {
10117                         r->color_profiles = NULL;
10118                 }
10119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10120                 if (_ptr_inf_path) {
10121                         NDR_PULL_ALLOC(ndr, r->inf_path);
10122                 } else {
10123                         r->inf_path = NULL;
10124                 }
10125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
10126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
10127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
10128                 if (_ptr_core_driver_dependencies) {
10129                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10130                 } else {
10131                         r->core_driver_dependencies = NULL;
10132                 }
10133                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10134                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10135                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10136         }
10137         if (ndr_flags & NDR_BUFFERS) {
10138                 if (r->driver_name) {
10139                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10140                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10141                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
10142                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
10143                         size_driver_name_1 = ndr_get_array_size(ndr, &r->driver_name);
10144                         length_driver_name_1 = ndr_get_array_length(ndr, &r->driver_name);
10145                         if (length_driver_name_1 > size_driver_name_1) {
10146                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_name_1, length_driver_name_1);
10147                         }
10148                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_name_1, sizeof(uint16_t)));
10149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, length_driver_name_1, sizeof(uint16_t), CH_UTF16));
10150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10151                 }
10152                 if (r->architecture) {
10153                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10154                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10155                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
10156                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
10157                         size_architecture_1 = ndr_get_array_size(ndr, &r->architecture);
10158                         length_architecture_1 = ndr_get_array_length(ndr, &r->architecture);
10159                         if (length_architecture_1 > size_architecture_1) {
10160                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
10161                         }
10162                         NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
10163                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
10164                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10165                 }
10166                 if (r->driver_path) {
10167                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10168                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10169                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
10170                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
10171                         size_driver_path_1 = ndr_get_array_size(ndr, &r->driver_path);
10172                         length_driver_path_1 = ndr_get_array_length(ndr, &r->driver_path);
10173                         if (length_driver_path_1 > size_driver_path_1) {
10174                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_path_1, length_driver_path_1);
10175                         }
10176                         NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_path_1, sizeof(uint16_t)));
10177                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, length_driver_path_1, sizeof(uint16_t), CH_UTF16));
10178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10179                 }
10180                 if (r->data_file) {
10181                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10182                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10183                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
10184                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
10185                         size_data_file_1 = ndr_get_array_size(ndr, &r->data_file);
10186                         length_data_file_1 = ndr_get_array_length(ndr, &r->data_file);
10187                         if (length_data_file_1 > size_data_file_1) {
10188                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_file_1, length_data_file_1);
10189                         }
10190                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_file_1, sizeof(uint16_t)));
10191                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, length_data_file_1, sizeof(uint16_t), CH_UTF16));
10192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10193                 }
10194                 if (r->config_file) {
10195                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10196                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10197                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
10198                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
10199                         size_config_file_1 = ndr_get_array_size(ndr, &r->config_file);
10200                         length_config_file_1 = ndr_get_array_length(ndr, &r->config_file);
10201                         if (length_config_file_1 > size_config_file_1) {
10202                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_config_file_1, length_config_file_1);
10203                         }
10204                         NDR_CHECK(ndr_check_string_terminator(ndr, length_config_file_1, sizeof(uint16_t)));
10205                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, length_config_file_1, sizeof(uint16_t), CH_UTF16));
10206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10207                 }
10208                 if (r->help_file) {
10209                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10210                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
10212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
10213                         size_help_file_1 = ndr_get_array_size(ndr, &r->help_file);
10214                         length_help_file_1 = ndr_get_array_length(ndr, &r->help_file);
10215                         if (length_help_file_1 > size_help_file_1) {
10216                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_help_file_1, length_help_file_1);
10217                         }
10218                         NDR_CHECK(ndr_check_string_terminator(ndr, length_help_file_1, sizeof(uint16_t)));
10219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, length_help_file_1, sizeof(uint16_t), CH_UTF16));
10220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10221                 }
10222                 if (r->monitor_name) {
10223                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10224                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10225                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
10226                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
10227                         size_monitor_name_1 = ndr_get_array_size(ndr, &r->monitor_name);
10228                         length_monitor_name_1 = ndr_get_array_length(ndr, &r->monitor_name);
10229                         if (length_monitor_name_1 > size_monitor_name_1) {
10230                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_monitor_name_1, length_monitor_name_1);
10231                         }
10232                         NDR_CHECK(ndr_check_string_terminator(ndr, length_monitor_name_1, sizeof(uint16_t)));
10233                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, length_monitor_name_1, sizeof(uint16_t), CH_UTF16));
10234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10235                 }
10236                 if (r->default_datatype) {
10237                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10238                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10239                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
10240                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
10241                         size_default_datatype_1 = ndr_get_array_size(ndr, &r->default_datatype);
10242                         length_default_datatype_1 = ndr_get_array_length(ndr, &r->default_datatype);
10243                         if (length_default_datatype_1 > size_default_datatype_1) {
10244                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_default_datatype_1, length_default_datatype_1);
10245                         }
10246                         NDR_CHECK(ndr_check_string_terminator(ndr, length_default_datatype_1, sizeof(uint16_t)));
10247                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, length_default_datatype_1, sizeof(uint16_t), CH_UTF16));
10248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10249                 }
10250                 if (r->dependent_files) {
10251                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10252                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10253                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10254                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10255                 }
10256                 if (r->previous_names) {
10257                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10258                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10259                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10261                 }
10262                 if (r->manufacturer_name) {
10263                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10264                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10266                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10267                         size_manufacturer_name_1 = ndr_get_array_size(ndr, &r->manufacturer_name);
10268                         length_manufacturer_name_1 = ndr_get_array_length(ndr, &r->manufacturer_name);
10269                         if (length_manufacturer_name_1 > size_manufacturer_name_1) {
10270                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_manufacturer_name_1, length_manufacturer_name_1);
10271                         }
10272                         NDR_CHECK(ndr_check_string_terminator(ndr, length_manufacturer_name_1, sizeof(uint16_t)));
10273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, length_manufacturer_name_1, sizeof(uint16_t), CH_UTF16));
10274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10275                 }
10276                 if (r->manufacturer_url) {
10277                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10278                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10280                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10281                         size_manufacturer_url_1 = ndr_get_array_size(ndr, &r->manufacturer_url);
10282                         length_manufacturer_url_1 = ndr_get_array_length(ndr, &r->manufacturer_url);
10283                         if (length_manufacturer_url_1 > size_manufacturer_url_1) {
10284                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_manufacturer_url_1, length_manufacturer_url_1);
10285                         }
10286                         NDR_CHECK(ndr_check_string_terminator(ndr, length_manufacturer_url_1, sizeof(uint16_t)));
10287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, length_manufacturer_url_1, sizeof(uint16_t), CH_UTF16));
10288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10289                 }
10290                 if (r->hardware_id) {
10291                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10292                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10295                         size_hardware_id_1 = ndr_get_array_size(ndr, &r->hardware_id);
10296                         length_hardware_id_1 = ndr_get_array_length(ndr, &r->hardware_id);
10297                         if (length_hardware_id_1 > size_hardware_id_1) {
10298                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_hardware_id_1, length_hardware_id_1);
10299                         }
10300                         NDR_CHECK(ndr_check_string_terminator(ndr, length_hardware_id_1, sizeof(uint16_t)));
10301                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, length_hardware_id_1, sizeof(uint16_t), CH_UTF16));
10302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10303                 }
10304                 if (r->provider) {
10305                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10306                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10307                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10308                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10309                         size_provider_1 = ndr_get_array_size(ndr, &r->provider);
10310                         length_provider_1 = ndr_get_array_length(ndr, &r->provider);
10311                         if (length_provider_1 > size_provider_1) {
10312                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_provider_1, length_provider_1);
10313                         }
10314                         NDR_CHECK(ndr_check_string_terminator(ndr, length_provider_1, sizeof(uint16_t)));
10315                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, length_provider_1, sizeof(uint16_t), CH_UTF16));
10316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10317                 }
10318                 if (r->print_processor) {
10319                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10320                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10323                         size_print_processor_1 = ndr_get_array_size(ndr, &r->print_processor);
10324                         length_print_processor_1 = ndr_get_array_length(ndr, &r->print_processor);
10325                         if (length_print_processor_1 > size_print_processor_1) {
10326                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_print_processor_1, length_print_processor_1);
10327                         }
10328                         NDR_CHECK(ndr_check_string_terminator(ndr, length_print_processor_1, sizeof(uint16_t)));
10329                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, length_print_processor_1, sizeof(uint16_t), CH_UTF16));
10330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10331                 }
10332                 if (r->vendor_setup) {
10333                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10334                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10337                         size_vendor_setup_1 = ndr_get_array_size(ndr, &r->vendor_setup);
10338                         length_vendor_setup_1 = ndr_get_array_length(ndr, &r->vendor_setup);
10339                         if (length_vendor_setup_1 > size_vendor_setup_1) {
10340                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_vendor_setup_1, length_vendor_setup_1);
10341                         }
10342                         NDR_CHECK(ndr_check_string_terminator(ndr, length_vendor_setup_1, sizeof(uint16_t)));
10343                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, length_vendor_setup_1, sizeof(uint16_t), CH_UTF16));
10344                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10345                 }
10346                 if (r->color_profiles) {
10347                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10348                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10349                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10351                 }
10352                 if (r->inf_path) {
10353                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10354                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10355                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10356                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10357                         size_inf_path_1 = ndr_get_array_size(ndr, &r->inf_path);
10358                         length_inf_path_1 = ndr_get_array_length(ndr, &r->inf_path);
10359                         if (length_inf_path_1 > size_inf_path_1) {
10360                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_inf_path_1, length_inf_path_1);
10361                         }
10362                         NDR_CHECK(ndr_check_string_terminator(ndr, length_inf_path_1, sizeof(uint16_t)));
10363                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, length_inf_path_1, sizeof(uint16_t), CH_UTF16));
10364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10365                 }
10366                 if (r->core_driver_dependencies) {
10367                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10368                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10369                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10371                 }
10372         }
10373         return NDR_ERR_SUCCESS;
10374 }
10375
10376 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10377 {
10378         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10379         ndr->depth++;
10380         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10381         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10382         ndr->depth++;
10383         if (r->driver_name) {
10384                 ndr_print_string(ndr, "driver_name", r->driver_name);
10385         }
10386         ndr->depth--;
10387         ndr_print_ptr(ndr, "architecture", r->architecture);
10388         ndr->depth++;
10389         if (r->architecture) {
10390                 ndr_print_string(ndr, "architecture", r->architecture);
10391         }
10392         ndr->depth--;
10393         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10394         ndr->depth++;
10395         if (r->driver_path) {
10396                 ndr_print_string(ndr, "driver_path", r->driver_path);
10397         }
10398         ndr->depth--;
10399         ndr_print_ptr(ndr, "data_file", r->data_file);
10400         ndr->depth++;
10401         if (r->data_file) {
10402                 ndr_print_string(ndr, "data_file", r->data_file);
10403         }
10404         ndr->depth--;
10405         ndr_print_ptr(ndr, "config_file", r->config_file);
10406         ndr->depth++;
10407         if (r->config_file) {
10408                 ndr_print_string(ndr, "config_file", r->config_file);
10409         }
10410         ndr->depth--;
10411         ndr_print_ptr(ndr, "help_file", r->help_file);
10412         ndr->depth++;
10413         if (r->help_file) {
10414                 ndr_print_string(ndr, "help_file", r->help_file);
10415         }
10416         ndr->depth--;
10417         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10418         ndr->depth++;
10419         if (r->monitor_name) {
10420                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10421         }
10422         ndr->depth--;
10423         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10424         ndr->depth++;
10425         if (r->default_datatype) {
10426                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10427         }
10428         ndr->depth--;
10429         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);
10430         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10431         ndr->depth++;
10432         if (r->dependent_files) {
10433                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10434         }
10435         ndr->depth--;
10436         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);
10437         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10438         ndr->depth++;
10439         if (r->previous_names) {
10440                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10441         }
10442         ndr->depth--;
10443         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10444         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10445         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10446         ndr->depth++;
10447         if (r->manufacturer_name) {
10448                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10449         }
10450         ndr->depth--;
10451         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10452         ndr->depth++;
10453         if (r->manufacturer_url) {
10454                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10455         }
10456         ndr->depth--;
10457         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10458         ndr->depth++;
10459         if (r->hardware_id) {
10460                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10461         }
10462         ndr->depth--;
10463         ndr_print_ptr(ndr, "provider", r->provider);
10464         ndr->depth++;
10465         if (r->provider) {
10466                 ndr_print_string(ndr, "provider", r->provider);
10467         }
10468         ndr->depth--;
10469         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10470         ndr->depth++;
10471         if (r->print_processor) {
10472                 ndr_print_string(ndr, "print_processor", r->print_processor);
10473         }
10474         ndr->depth--;
10475         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10476         ndr->depth++;
10477         if (r->vendor_setup) {
10478                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10479         }
10480         ndr->depth--;
10481         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);
10482         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10483         ndr->depth++;
10484         if (r->color_profiles) {
10485                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10486         }
10487         ndr->depth--;
10488         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10489         ndr->depth++;
10490         if (r->inf_path) {
10491                 ndr_print_string(ndr, "inf_path", r->inf_path);
10492         }
10493         ndr->depth--;
10494         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10495         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);
10496         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10497         ndr->depth++;
10498         if (r->core_driver_dependencies) {
10499                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10500         }
10501         ndr->depth--;
10502         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10503         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10504         ndr->depth--;
10505 }
10506
10507 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10508 {
10509         if (ndr_flags & NDR_SCALARS) {
10510                 int level = ndr_push_get_switch_value(ndr, r);
10511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10512                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10513                 switch (level) {
10514                         case 1: {
10515                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10516                         break; }
10517
10518                         case 2: {
10519                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10520                         break; }
10521
10522                         case 3: {
10523                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10524                         break; }
10525
10526                         case 4: {
10527                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10528                         break; }
10529
10530                         case 6: {
10531                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10532                         break; }
10533
10534                         case 8: {
10535                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10536                         break; }
10537
10538                         default:
10539                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10540                 }
10541         }
10542         if (ndr_flags & NDR_BUFFERS) {
10543                 int level = ndr_push_get_switch_value(ndr, r);
10544                 switch (level) {
10545                         case 1:
10546                                 if (r->info1) {
10547                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10548                                 }
10549                         break;
10550
10551                         case 2:
10552                                 if (r->info2) {
10553                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10554                                 }
10555                         break;
10556
10557                         case 3:
10558                                 if (r->info3) {
10559                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10560                                 }
10561                         break;
10562
10563                         case 4:
10564                                 if (r->info4) {
10565                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10566                                 }
10567                         break;
10568
10569                         case 6:
10570                                 if (r->info6) {
10571                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10572                                 }
10573                         break;
10574
10575                         case 8:
10576                                 if (r->info8) {
10577                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10578                                 }
10579                         break;
10580
10581                         default:
10582                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10583                 }
10584         }
10585         return NDR_ERR_SUCCESS;
10586 }
10587
10588 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10589 {
10590         int level;
10591         uint32_t _level;
10592         TALLOC_CTX *_mem_save_info1_0;
10593         uint32_t _ptr_info1;
10594         TALLOC_CTX *_mem_save_info2_0;
10595         uint32_t _ptr_info2;
10596         TALLOC_CTX *_mem_save_info3_0;
10597         uint32_t _ptr_info3;
10598         TALLOC_CTX *_mem_save_info4_0;
10599         uint32_t _ptr_info4;
10600         TALLOC_CTX *_mem_save_info6_0;
10601         uint32_t _ptr_info6;
10602         TALLOC_CTX *_mem_save_info8_0;
10603         uint32_t _ptr_info8;
10604         level = ndr_pull_get_switch_value(ndr, r);
10605         if (ndr_flags & NDR_SCALARS) {
10606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10607                 if (_level != level) {
10608                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10609                 }
10610                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10611                 switch (level) {
10612                         case 1: {
10613                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10614                                 if (_ptr_info1) {
10615                                         NDR_PULL_ALLOC(ndr, r->info1);
10616                                 } else {
10617                                         r->info1 = NULL;
10618                                 }
10619                         break; }
10620
10621                         case 2: {
10622                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10623                                 if (_ptr_info2) {
10624                                         NDR_PULL_ALLOC(ndr, r->info2);
10625                                 } else {
10626                                         r->info2 = NULL;
10627                                 }
10628                         break; }
10629
10630                         case 3: {
10631                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10632                                 if (_ptr_info3) {
10633                                         NDR_PULL_ALLOC(ndr, r->info3);
10634                                 } else {
10635                                         r->info3 = NULL;
10636                                 }
10637                         break; }
10638
10639                         case 4: {
10640                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10641                                 if (_ptr_info4) {
10642                                         NDR_PULL_ALLOC(ndr, r->info4);
10643                                 } else {
10644                                         r->info4 = NULL;
10645                                 }
10646                         break; }
10647
10648                         case 6: {
10649                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10650                                 if (_ptr_info6) {
10651                                         NDR_PULL_ALLOC(ndr, r->info6);
10652                                 } else {
10653                                         r->info6 = NULL;
10654                                 }
10655                         break; }
10656
10657                         case 8: {
10658                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10659                                 if (_ptr_info8) {
10660                                         NDR_PULL_ALLOC(ndr, r->info8);
10661                                 } else {
10662                                         r->info8 = NULL;
10663                                 }
10664                         break; }
10665
10666                         default:
10667                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10668                 }
10669         }
10670         if (ndr_flags & NDR_BUFFERS) {
10671                 switch (level) {
10672                         case 1:
10673                                 if (r->info1) {
10674                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10675                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10676                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10677                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10678                                 }
10679                         break;
10680
10681                         case 2:
10682                                 if (r->info2) {
10683                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10684                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10685                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10686                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10687                                 }
10688                         break;
10689
10690                         case 3:
10691                                 if (r->info3) {
10692                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10693                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10694                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10695                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10696                                 }
10697                         break;
10698
10699                         case 4:
10700                                 if (r->info4) {
10701                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10702                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10703                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10704                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10705                                 }
10706                         break;
10707
10708                         case 6:
10709                                 if (r->info6) {
10710                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10711                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10712                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10713                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10714                                 }
10715                         break;
10716
10717                         case 8:
10718                                 if (r->info8) {
10719                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10720                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10721                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10722                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10723                                 }
10724                         break;
10725
10726                         default:
10727                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10728                 }
10729         }
10730         return NDR_ERR_SUCCESS;
10731 }
10732
10733 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10734 {
10735         int level;
10736         level = ndr_print_get_switch_value(ndr, r);
10737         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10738         switch (level) {
10739                 case 1:
10740                         ndr_print_ptr(ndr, "info1", r->info1);
10741                         ndr->depth++;
10742                         if (r->info1) {
10743                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10744                         }
10745                         ndr->depth--;
10746                 break;
10747
10748                 case 2:
10749                         ndr_print_ptr(ndr, "info2", r->info2);
10750                         ndr->depth++;
10751                         if (r->info2) {
10752                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10753                         }
10754                         ndr->depth--;
10755                 break;
10756
10757                 case 3:
10758                         ndr_print_ptr(ndr, "info3", r->info3);
10759                         ndr->depth++;
10760                         if (r->info3) {
10761                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10762                         }
10763                         ndr->depth--;
10764                 break;
10765
10766                 case 4:
10767                         ndr_print_ptr(ndr, "info4", r->info4);
10768                         ndr->depth++;
10769                         if (r->info4) {
10770                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10771                         }
10772                         ndr->depth--;
10773                 break;
10774
10775                 case 6:
10776                         ndr_print_ptr(ndr, "info6", r->info6);
10777                         ndr->depth++;
10778                         if (r->info6) {
10779                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10780                         }
10781                         ndr->depth--;
10782                 break;
10783
10784                 case 8:
10785                         ndr_print_ptr(ndr, "info8", r->info8);
10786                         ndr->depth++;
10787                         if (r->info8) {
10788                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10789                         }
10790                         ndr->depth--;
10791                 break;
10792
10793                 default:
10794                         ndr_print_bad_level(ndr, name, level);
10795         }
10796 }
10797
10798 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10799 {
10800         if (ndr_flags & NDR_SCALARS) {
10801                 NDR_CHECK(ndr_push_align(ndr, 5));
10802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10803                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10804                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10805                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10806         }
10807         if (ndr_flags & NDR_BUFFERS) {
10808                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10809         }
10810         return NDR_ERR_SUCCESS;
10811 }
10812
10813 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10814 {
10815         if (ndr_flags & NDR_SCALARS) {
10816                 NDR_CHECK(ndr_pull_align(ndr, 5));
10817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10818                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10819                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10820                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10821         }
10822         if (ndr_flags & NDR_BUFFERS) {
10823                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10824         }
10825         return NDR_ERR_SUCCESS;
10826 }
10827
10828 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10829 {
10830         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10831         ndr->depth++;
10832         ndr_print_uint32(ndr, "level", r->level);
10833         ndr_print_set_switch_value(ndr, &r->info, r->level);
10834         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10835         ndr->depth--;
10836 }
10837
10838 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10839 {
10840         if (ndr_flags & NDR_SCALARS) {
10841                 NDR_CHECK(ndr_push_align(ndr, 5));
10842                 {
10843                         uint32_t _flags_save_string = ndr->flags;
10844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10845                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10846                         ndr->flags = _flags_save_string;
10847                 }
10848                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10849         }
10850         if (ndr_flags & NDR_BUFFERS) {
10851                 {
10852                         uint32_t _flags_save_string = ndr->flags;
10853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10854                         if (r->driver_name) {
10855                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10856                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10857                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10858                         }
10859                         ndr->flags = _flags_save_string;
10860                 }
10861         }
10862         return NDR_ERR_SUCCESS;
10863 }
10864
10865 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10866 {
10867         uint32_t _ptr_driver_name;
10868         TALLOC_CTX *_mem_save_driver_name_0;
10869         if (ndr_flags & NDR_SCALARS) {
10870                 NDR_CHECK(ndr_pull_align(ndr, 5));
10871                 {
10872                         uint32_t _flags_save_string = ndr->flags;
10873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10874                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10875                         if (_ptr_driver_name) {
10876                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10877                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10878                         } else {
10879                                 r->driver_name = NULL;
10880                         }
10881                         ndr->flags = _flags_save_string;
10882                 }
10883                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10884         }
10885         if (ndr_flags & NDR_BUFFERS) {
10886                 {
10887                         uint32_t _flags_save_string = ndr->flags;
10888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10889                         if (r->driver_name) {
10890                                 uint32_t _relative_save_offset;
10891                                 _relative_save_offset = ndr->offset;
10892                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10893                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10894                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10895                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10896                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10897                                 ndr->offset = _relative_save_offset;
10898                         }
10899                         ndr->flags = _flags_save_string;
10900                 }
10901         }
10902         return NDR_ERR_SUCCESS;
10903 }
10904
10905 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10906 {
10907         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10908         ndr->depth++;
10909         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10910         ndr->depth++;
10911         if (r->driver_name) {
10912                 ndr_print_string(ndr, "driver_name", r->driver_name);
10913         }
10914         ndr->depth--;
10915         ndr->depth--;
10916 }
10917
10918 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10919 {
10920         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10921 }
10922
10923 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10924 {
10925         if (ndr_flags & NDR_SCALARS) {
10926                 NDR_CHECK(ndr_push_align(ndr, 5));
10927                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10928                 {
10929                         uint32_t _flags_save_string = ndr->flags;
10930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10931                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
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|LIBNDR_FLAG_ALIGN2);
10937                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10938                         ndr->flags = _flags_save_string;
10939                 }
10940                 {
10941                         uint32_t _flags_save_string = ndr->flags;
10942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10943                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10944                         ndr->flags = _flags_save_string;
10945                 }
10946                 {
10947                         uint32_t _flags_save_string = ndr->flags;
10948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10949                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10950                         ndr->flags = _flags_save_string;
10951                 }
10952                 {
10953                         uint32_t _flags_save_string = ndr->flags;
10954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10955                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10956                         ndr->flags = _flags_save_string;
10957                 }
10958                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10959         }
10960         if (ndr_flags & NDR_BUFFERS) {
10961                 {
10962                         uint32_t _flags_save_string = ndr->flags;
10963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10964                         if (r->driver_name) {
10965                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10966                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10967                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10968                         }
10969                         ndr->flags = _flags_save_string;
10970                 }
10971                 {
10972                         uint32_t _flags_save_string = ndr->flags;
10973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10974                         if (r->architecture) {
10975                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
10976                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10977                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
10978                         }
10979                         ndr->flags = _flags_save_string;
10980                 }
10981                 {
10982                         uint32_t _flags_save_string = ndr->flags;
10983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10984                         if (r->driver_path) {
10985                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
10986                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10987                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
10988                         }
10989                         ndr->flags = _flags_save_string;
10990                 }
10991                 {
10992                         uint32_t _flags_save_string = ndr->flags;
10993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10994                         if (r->data_file) {
10995                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
10996                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10997                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
10998                         }
10999                         ndr->flags = _flags_save_string;
11000                 }
11001                 {
11002                         uint32_t _flags_save_string = ndr->flags;
11003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11004                         if (r->config_file) {
11005                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11007                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11008                         }
11009                         ndr->flags = _flags_save_string;
11010                 }
11011         }
11012         return NDR_ERR_SUCCESS;
11013 }
11014
11015 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
11016 {
11017         uint32_t _ptr_driver_name;
11018         TALLOC_CTX *_mem_save_driver_name_0;
11019         uint32_t _ptr_architecture;
11020         TALLOC_CTX *_mem_save_architecture_0;
11021         uint32_t _ptr_driver_path;
11022         TALLOC_CTX *_mem_save_driver_path_0;
11023         uint32_t _ptr_data_file;
11024         TALLOC_CTX *_mem_save_data_file_0;
11025         uint32_t _ptr_config_file;
11026         TALLOC_CTX *_mem_save_config_file_0;
11027         if (ndr_flags & NDR_SCALARS) {
11028                 NDR_CHECK(ndr_pull_align(ndr, 5));
11029                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11030                 {
11031                         uint32_t _flags_save_string = ndr->flags;
11032                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11033                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11034                         if (_ptr_driver_name) {
11035                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11036                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11037                         } else {
11038                                 r->driver_name = NULL;
11039                         }
11040                         ndr->flags = _flags_save_string;
11041                 }
11042                 {
11043                         uint32_t _flags_save_string = ndr->flags;
11044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11045                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11046                         if (_ptr_architecture) {
11047                                 NDR_PULL_ALLOC(ndr, r->architecture);
11048                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11049                         } else {
11050                                 r->architecture = NULL;
11051                         }
11052                         ndr->flags = _flags_save_string;
11053                 }
11054                 {
11055                         uint32_t _flags_save_string = ndr->flags;
11056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11057                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11058                         if (_ptr_driver_path) {
11059                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11060                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11061                         } else {
11062                                 r->driver_path = NULL;
11063                         }
11064                         ndr->flags = _flags_save_string;
11065                 }
11066                 {
11067                         uint32_t _flags_save_string = ndr->flags;
11068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11069                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11070                         if (_ptr_data_file) {
11071                                 NDR_PULL_ALLOC(ndr, r->data_file);
11072                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11073                         } else {
11074                                 r->data_file = NULL;
11075                         }
11076                         ndr->flags = _flags_save_string;
11077                 }
11078                 {
11079                         uint32_t _flags_save_string = ndr->flags;
11080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11081                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11082                         if (_ptr_config_file) {
11083                                 NDR_PULL_ALLOC(ndr, r->config_file);
11084                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11085                         } else {
11086                                 r->config_file = NULL;
11087                         }
11088                         ndr->flags = _flags_save_string;
11089                 }
11090                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11091         }
11092         if (ndr_flags & NDR_BUFFERS) {
11093                 {
11094                         uint32_t _flags_save_string = ndr->flags;
11095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11096                         if (r->driver_name) {
11097                                 uint32_t _relative_save_offset;
11098                                 _relative_save_offset = ndr->offset;
11099                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11100                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11101                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11102                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11103                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11104                                 ndr->offset = _relative_save_offset;
11105                         }
11106                         ndr->flags = _flags_save_string;
11107                 }
11108                 {
11109                         uint32_t _flags_save_string = ndr->flags;
11110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11111                         if (r->architecture) {
11112                                 uint32_t _relative_save_offset;
11113                                 _relative_save_offset = ndr->offset;
11114                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11115                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11116                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11117                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11118                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11119                                 ndr->offset = _relative_save_offset;
11120                         }
11121                         ndr->flags = _flags_save_string;
11122                 }
11123                 {
11124                         uint32_t _flags_save_string = ndr->flags;
11125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11126                         if (r->driver_path) {
11127                                 uint32_t _relative_save_offset;
11128                                 _relative_save_offset = ndr->offset;
11129                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11130                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11131                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11132                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11133                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11134                                 ndr->offset = _relative_save_offset;
11135                         }
11136                         ndr->flags = _flags_save_string;
11137                 }
11138                 {
11139                         uint32_t _flags_save_string = ndr->flags;
11140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11141                         if (r->data_file) {
11142                                 uint32_t _relative_save_offset;
11143                                 _relative_save_offset = ndr->offset;
11144                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11145                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11146                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11147                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11148                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11149                                 ndr->offset = _relative_save_offset;
11150                         }
11151                         ndr->flags = _flags_save_string;
11152                 }
11153                 {
11154                         uint32_t _flags_save_string = ndr->flags;
11155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11156                         if (r->config_file) {
11157                                 uint32_t _relative_save_offset;
11158                                 _relative_save_offset = ndr->offset;
11159                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11160                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11161                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11162                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11163                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11164                                 ndr->offset = _relative_save_offset;
11165                         }
11166                         ndr->flags = _flags_save_string;
11167                 }
11168         }
11169         return NDR_ERR_SUCCESS;
11170 }
11171
11172 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
11173 {
11174         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
11175         ndr->depth++;
11176         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11177         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11178         ndr->depth++;
11179         if (r->driver_name) {
11180                 ndr_print_string(ndr, "driver_name", r->driver_name);
11181         }
11182         ndr->depth--;
11183         ndr_print_ptr(ndr, "architecture", r->architecture);
11184         ndr->depth++;
11185         if (r->architecture) {
11186                 ndr_print_string(ndr, "architecture", r->architecture);
11187         }
11188         ndr->depth--;
11189         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11190         ndr->depth++;
11191         if (r->driver_path) {
11192                 ndr_print_string(ndr, "driver_path", r->driver_path);
11193         }
11194         ndr->depth--;
11195         ndr_print_ptr(ndr, "data_file", r->data_file);
11196         ndr->depth++;
11197         if (r->data_file) {
11198                 ndr_print_string(ndr, "data_file", r->data_file);
11199         }
11200         ndr->depth--;
11201         ndr_print_ptr(ndr, "config_file", r->config_file);
11202         ndr->depth++;
11203         if (r->config_file) {
11204                 ndr_print_string(ndr, "config_file", r->config_file);
11205         }
11206         ndr->depth--;
11207         ndr->depth--;
11208 }
11209
11210 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
11211 {
11212         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
11213 }
11214
11215 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
11216 {
11217         if (ndr_flags & NDR_SCALARS) {
11218                 NDR_CHECK(ndr_push_align(ndr, 5));
11219                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11220                 {
11221                         uint32_t _flags_save_string = ndr->flags;
11222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11223                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11224                         ndr->flags = _flags_save_string;
11225                 }
11226                 {
11227                         uint32_t _flags_save_string = ndr->flags;
11228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11229                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11230                         ndr->flags = _flags_save_string;
11231                 }
11232                 {
11233                         uint32_t _flags_save_string = ndr->flags;
11234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11235                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11236                         ndr->flags = _flags_save_string;
11237                 }
11238                 {
11239                         uint32_t _flags_save_string = ndr->flags;
11240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11242                         ndr->flags = _flags_save_string;
11243                 }
11244                 {
11245                         uint32_t _flags_save_string = ndr->flags;
11246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11247                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11248                         ndr->flags = _flags_save_string;
11249                 }
11250                 {
11251                         uint32_t _flags_save_string = ndr->flags;
11252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11253                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11254                         ndr->flags = _flags_save_string;
11255                 }
11256                 {
11257                         uint32_t _flags_save_string_array = ndr->flags;
11258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11260                         ndr->flags = _flags_save_string_array;
11261                 }
11262                 {
11263                         uint32_t _flags_save_string = ndr->flags;
11264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11266                         ndr->flags = _flags_save_string;
11267                 }
11268                 {
11269                         uint32_t _flags_save_string = ndr->flags;
11270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11271                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11272                         ndr->flags = _flags_save_string;
11273                 }
11274                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11275         }
11276         if (ndr_flags & NDR_BUFFERS) {
11277                 {
11278                         uint32_t _flags_save_string = ndr->flags;
11279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11280                         if (r->driver_name) {
11281                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11282                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11283                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11284                         }
11285                         ndr->flags = _flags_save_string;
11286                 }
11287                 {
11288                         uint32_t _flags_save_string = ndr->flags;
11289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11290                         if (r->architecture) {
11291                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11292                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11293                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11294                         }
11295                         ndr->flags = _flags_save_string;
11296                 }
11297                 {
11298                         uint32_t _flags_save_string = ndr->flags;
11299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11300                         if (r->driver_path) {
11301                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11302                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11303                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11304                         }
11305                         ndr->flags = _flags_save_string;
11306                 }
11307                 {
11308                         uint32_t _flags_save_string = ndr->flags;
11309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11310                         if (r->data_file) {
11311                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11312                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11313                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11314                         }
11315                         ndr->flags = _flags_save_string;
11316                 }
11317                 {
11318                         uint32_t _flags_save_string = ndr->flags;
11319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11320                         if (r->config_file) {
11321                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11322                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11323                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11324                         }
11325                         ndr->flags = _flags_save_string;
11326                 }
11327                 {
11328                         uint32_t _flags_save_string = ndr->flags;
11329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11330                         if (r->help_file) {
11331                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11332                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11333                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11334                         }
11335                         ndr->flags = _flags_save_string;
11336                 }
11337                 {
11338                         uint32_t _flags_save_string_array = ndr->flags;
11339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11340                         if (r->dependent_files) {
11341                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11342                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11343                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11344                         }
11345                         ndr->flags = _flags_save_string_array;
11346                 }
11347                 {
11348                         uint32_t _flags_save_string = ndr->flags;
11349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11350                         if (r->monitor_name) {
11351                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11352                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11353                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11354                         }
11355                         ndr->flags = _flags_save_string;
11356                 }
11357                 {
11358                         uint32_t _flags_save_string = ndr->flags;
11359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11360                         if (r->default_datatype) {
11361                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11363                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11364                         }
11365                         ndr->flags = _flags_save_string;
11366                 }
11367         }
11368         return NDR_ERR_SUCCESS;
11369 }
11370
11371 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11372 {
11373         uint32_t _ptr_driver_name;
11374         TALLOC_CTX *_mem_save_driver_name_0;
11375         uint32_t _ptr_architecture;
11376         TALLOC_CTX *_mem_save_architecture_0;
11377         uint32_t _ptr_driver_path;
11378         TALLOC_CTX *_mem_save_driver_path_0;
11379         uint32_t _ptr_data_file;
11380         TALLOC_CTX *_mem_save_data_file_0;
11381         uint32_t _ptr_config_file;
11382         TALLOC_CTX *_mem_save_config_file_0;
11383         uint32_t _ptr_help_file;
11384         TALLOC_CTX *_mem_save_help_file_0;
11385         uint32_t _ptr_dependent_files;
11386         TALLOC_CTX *_mem_save_dependent_files_0;
11387         uint32_t _ptr_monitor_name;
11388         TALLOC_CTX *_mem_save_monitor_name_0;
11389         uint32_t _ptr_default_datatype;
11390         TALLOC_CTX *_mem_save_default_datatype_0;
11391         if (ndr_flags & NDR_SCALARS) {
11392                 NDR_CHECK(ndr_pull_align(ndr, 5));
11393                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11394                 {
11395                         uint32_t _flags_save_string = ndr->flags;
11396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11398                         if (_ptr_driver_name) {
11399                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11401                         } else {
11402                                 r->driver_name = NULL;
11403                         }
11404                         ndr->flags = _flags_save_string;
11405                 }
11406                 {
11407                         uint32_t _flags_save_string = ndr->flags;
11408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11409                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11410                         if (_ptr_architecture) {
11411                                 NDR_PULL_ALLOC(ndr, r->architecture);
11412                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11413                         } else {
11414                                 r->architecture = NULL;
11415                         }
11416                         ndr->flags = _flags_save_string;
11417                 }
11418                 {
11419                         uint32_t _flags_save_string = ndr->flags;
11420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11421                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11422                         if (_ptr_driver_path) {
11423                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11424                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11425                         } else {
11426                                 r->driver_path = NULL;
11427                         }
11428                         ndr->flags = _flags_save_string;
11429                 }
11430                 {
11431                         uint32_t _flags_save_string = ndr->flags;
11432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11433                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11434                         if (_ptr_data_file) {
11435                                 NDR_PULL_ALLOC(ndr, r->data_file);
11436                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11437                         } else {
11438                                 r->data_file = NULL;
11439                         }
11440                         ndr->flags = _flags_save_string;
11441                 }
11442                 {
11443                         uint32_t _flags_save_string = ndr->flags;
11444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11445                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11446                         if (_ptr_config_file) {
11447                                 NDR_PULL_ALLOC(ndr, r->config_file);
11448                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11449                         } else {
11450                                 r->config_file = NULL;
11451                         }
11452                         ndr->flags = _flags_save_string;
11453                 }
11454                 {
11455                         uint32_t _flags_save_string = ndr->flags;
11456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11457                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11458                         if (_ptr_help_file) {
11459                                 NDR_PULL_ALLOC(ndr, r->help_file);
11460                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11461                         } else {
11462                                 r->help_file = NULL;
11463                         }
11464                         ndr->flags = _flags_save_string;
11465                 }
11466                 {
11467                         uint32_t _flags_save_string_array = ndr->flags;
11468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11469                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11470                         if (_ptr_dependent_files) {
11471                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11472                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11473                         } else {
11474                                 r->dependent_files = NULL;
11475                         }
11476                         ndr->flags = _flags_save_string_array;
11477                 }
11478                 {
11479                         uint32_t _flags_save_string = ndr->flags;
11480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11481                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11482                         if (_ptr_monitor_name) {
11483                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11484                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11485                         } else {
11486                                 r->monitor_name = NULL;
11487                         }
11488                         ndr->flags = _flags_save_string;
11489                 }
11490                 {
11491                         uint32_t _flags_save_string = ndr->flags;
11492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11493                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11494                         if (_ptr_default_datatype) {
11495                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11496                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11497                         } else {
11498                                 r->default_datatype = NULL;
11499                         }
11500                         ndr->flags = _flags_save_string;
11501                 }
11502                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11503         }
11504         if (ndr_flags & NDR_BUFFERS) {
11505                 {
11506                         uint32_t _flags_save_string = ndr->flags;
11507                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11508                         if (r->driver_name) {
11509                                 uint32_t _relative_save_offset;
11510                                 _relative_save_offset = ndr->offset;
11511                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11512                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11513                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11514                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11515                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11516                                 ndr->offset = _relative_save_offset;
11517                         }
11518                         ndr->flags = _flags_save_string;
11519                 }
11520                 {
11521                         uint32_t _flags_save_string = ndr->flags;
11522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11523                         if (r->architecture) {
11524                                 uint32_t _relative_save_offset;
11525                                 _relative_save_offset = ndr->offset;
11526                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11527                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11528                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11529                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11530                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11531                                 ndr->offset = _relative_save_offset;
11532                         }
11533                         ndr->flags = _flags_save_string;
11534                 }
11535                 {
11536                         uint32_t _flags_save_string = ndr->flags;
11537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11538                         if (r->driver_path) {
11539                                 uint32_t _relative_save_offset;
11540                                 _relative_save_offset = ndr->offset;
11541                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11542                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11543                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11544                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11545                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11546                                 ndr->offset = _relative_save_offset;
11547                         }
11548                         ndr->flags = _flags_save_string;
11549                 }
11550                 {
11551                         uint32_t _flags_save_string = ndr->flags;
11552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11553                         if (r->data_file) {
11554                                 uint32_t _relative_save_offset;
11555                                 _relative_save_offset = ndr->offset;
11556                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11557                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11558                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11559                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11560                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11561                                 ndr->offset = _relative_save_offset;
11562                         }
11563                         ndr->flags = _flags_save_string;
11564                 }
11565                 {
11566                         uint32_t _flags_save_string = ndr->flags;
11567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11568                         if (r->config_file) {
11569                                 uint32_t _relative_save_offset;
11570                                 _relative_save_offset = ndr->offset;
11571                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11572                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11573                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11574                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11575                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11576                                 ndr->offset = _relative_save_offset;
11577                         }
11578                         ndr->flags = _flags_save_string;
11579                 }
11580                 {
11581                         uint32_t _flags_save_string = ndr->flags;
11582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11583                         if (r->help_file) {
11584                                 uint32_t _relative_save_offset;
11585                                 _relative_save_offset = ndr->offset;
11586                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11587                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11588                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11589                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11590                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11591                                 ndr->offset = _relative_save_offset;
11592                         }
11593                         ndr->flags = _flags_save_string;
11594                 }
11595                 {
11596                         uint32_t _flags_save_string_array = ndr->flags;
11597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11598                         if (r->dependent_files) {
11599                                 uint32_t _relative_save_offset;
11600                                 _relative_save_offset = ndr->offset;
11601                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11602                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11603                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11604                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11605                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11606                                 ndr->offset = _relative_save_offset;
11607                         }
11608                         ndr->flags = _flags_save_string_array;
11609                 }
11610                 {
11611                         uint32_t _flags_save_string = ndr->flags;
11612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11613                         if (r->monitor_name) {
11614                                 uint32_t _relative_save_offset;
11615                                 _relative_save_offset = ndr->offset;
11616                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11617                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11618                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11619                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11620                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11621                                 ndr->offset = _relative_save_offset;
11622                         }
11623                         ndr->flags = _flags_save_string;
11624                 }
11625                 {
11626                         uint32_t _flags_save_string = ndr->flags;
11627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11628                         if (r->default_datatype) {
11629                                 uint32_t _relative_save_offset;
11630                                 _relative_save_offset = ndr->offset;
11631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11632                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11633                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11636                                 ndr->offset = _relative_save_offset;
11637                         }
11638                         ndr->flags = _flags_save_string;
11639                 }
11640         }
11641         return NDR_ERR_SUCCESS;
11642 }
11643
11644 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11645 {
11646         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11647         ndr->depth++;
11648         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11649         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11650         ndr->depth++;
11651         if (r->driver_name) {
11652                 ndr_print_string(ndr, "driver_name", r->driver_name);
11653         }
11654         ndr->depth--;
11655         ndr_print_ptr(ndr, "architecture", r->architecture);
11656         ndr->depth++;
11657         if (r->architecture) {
11658                 ndr_print_string(ndr, "architecture", r->architecture);
11659         }
11660         ndr->depth--;
11661         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11662         ndr->depth++;
11663         if (r->driver_path) {
11664                 ndr_print_string(ndr, "driver_path", r->driver_path);
11665         }
11666         ndr->depth--;
11667         ndr_print_ptr(ndr, "data_file", r->data_file);
11668         ndr->depth++;
11669         if (r->data_file) {
11670                 ndr_print_string(ndr, "data_file", r->data_file);
11671         }
11672         ndr->depth--;
11673         ndr_print_ptr(ndr, "config_file", r->config_file);
11674         ndr->depth++;
11675         if (r->config_file) {
11676                 ndr_print_string(ndr, "config_file", r->config_file);
11677         }
11678         ndr->depth--;
11679         ndr_print_ptr(ndr, "help_file", r->help_file);
11680         ndr->depth++;
11681         if (r->help_file) {
11682                 ndr_print_string(ndr, "help_file", r->help_file);
11683         }
11684         ndr->depth--;
11685         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11686         ndr->depth++;
11687         if (r->dependent_files) {
11688                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11689         }
11690         ndr->depth--;
11691         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11692         ndr->depth++;
11693         if (r->monitor_name) {
11694                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11695         }
11696         ndr->depth--;
11697         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11698         ndr->depth++;
11699         if (r->default_datatype) {
11700                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11701         }
11702         ndr->depth--;
11703         ndr->depth--;
11704 }
11705
11706 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11707 {
11708         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11709 }
11710
11711 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11712 {
11713         if (ndr_flags & NDR_SCALARS) {
11714                 NDR_CHECK(ndr_push_align(ndr, 5));
11715                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11716                 {
11717                         uint32_t _flags_save_string = ndr->flags;
11718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11719                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11720                         ndr->flags = _flags_save_string;
11721                 }
11722                 {
11723                         uint32_t _flags_save_string = ndr->flags;
11724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11725                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11726                         ndr->flags = _flags_save_string;
11727                 }
11728                 {
11729                         uint32_t _flags_save_string = ndr->flags;
11730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11731                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11732                         ndr->flags = _flags_save_string;
11733                 }
11734                 {
11735                         uint32_t _flags_save_string = ndr->flags;
11736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11737                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11738                         ndr->flags = _flags_save_string;
11739                 }
11740                 {
11741                         uint32_t _flags_save_string = ndr->flags;
11742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11743                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11744                         ndr->flags = _flags_save_string;
11745                 }
11746                 {
11747                         uint32_t _flags_save_string = ndr->flags;
11748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11749                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11750                         ndr->flags = _flags_save_string;
11751                 }
11752                 {
11753                         uint32_t _flags_save_string_array = ndr->flags;
11754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11755                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11756                         ndr->flags = _flags_save_string_array;
11757                 }
11758                 {
11759                         uint32_t _flags_save_string = ndr->flags;
11760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11761                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11762                         ndr->flags = _flags_save_string;
11763                 }
11764                 {
11765                         uint32_t _flags_save_string = ndr->flags;
11766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11767                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11768                         ndr->flags = _flags_save_string;
11769                 }
11770                 {
11771                         uint32_t _flags_save_string_array = ndr->flags;
11772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11773                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11774                         ndr->flags = _flags_save_string_array;
11775                 }
11776                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11777         }
11778         if (ndr_flags & NDR_BUFFERS) {
11779                 {
11780                         uint32_t _flags_save_string = ndr->flags;
11781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11782                         if (r->driver_name) {
11783                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11784                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11785                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11786                         }
11787                         ndr->flags = _flags_save_string;
11788                 }
11789                 {
11790                         uint32_t _flags_save_string = ndr->flags;
11791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11792                         if (r->architecture) {
11793                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11794                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11795                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11796                         }
11797                         ndr->flags = _flags_save_string;
11798                 }
11799                 {
11800                         uint32_t _flags_save_string = ndr->flags;
11801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11802                         if (r->driver_path) {
11803                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11804                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11805                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
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|LIBNDR_FLAG_ALIGN2);
11812                         if (r->data_file) {
11813                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11814                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11815                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11816                         }
11817                         ndr->flags = _flags_save_string;
11818                 }
11819                 {
11820                         uint32_t _flags_save_string = ndr->flags;
11821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11822                         if (r->config_file) {
11823                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11824                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11825                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11826                         }
11827                         ndr->flags = _flags_save_string;
11828                 }
11829                 {
11830                         uint32_t _flags_save_string = ndr->flags;
11831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11832                         if (r->help_file) {
11833                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11834                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11835                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11836                         }
11837                         ndr->flags = _flags_save_string;
11838                 }
11839                 {
11840                         uint32_t _flags_save_string_array = ndr->flags;
11841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11842                         if (r->dependent_files) {
11843                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11844                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11845                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11846                         }
11847                         ndr->flags = _flags_save_string_array;
11848                 }
11849                 {
11850                         uint32_t _flags_save_string = ndr->flags;
11851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11852                         if (r->monitor_name) {
11853                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11854                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11855                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11856                         }
11857                         ndr->flags = _flags_save_string;
11858                 }
11859                 {
11860                         uint32_t _flags_save_string = ndr->flags;
11861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11862                         if (r->default_datatype) {
11863                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11864                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11865                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11866                         }
11867                         ndr->flags = _flags_save_string;
11868                 }
11869                 {
11870                         uint32_t _flags_save_string_array = ndr->flags;
11871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11872                         if (r->previous_names) {
11873                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
11874                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11875                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
11876                         }
11877                         ndr->flags = _flags_save_string_array;
11878                 }
11879         }
11880         return NDR_ERR_SUCCESS;
11881 }
11882
11883 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11884 {
11885         uint32_t _ptr_driver_name;
11886         TALLOC_CTX *_mem_save_driver_name_0;
11887         uint32_t _ptr_architecture;
11888         TALLOC_CTX *_mem_save_architecture_0;
11889         uint32_t _ptr_driver_path;
11890         TALLOC_CTX *_mem_save_driver_path_0;
11891         uint32_t _ptr_data_file;
11892         TALLOC_CTX *_mem_save_data_file_0;
11893         uint32_t _ptr_config_file;
11894         TALLOC_CTX *_mem_save_config_file_0;
11895         uint32_t _ptr_help_file;
11896         TALLOC_CTX *_mem_save_help_file_0;
11897         uint32_t _ptr_dependent_files;
11898         TALLOC_CTX *_mem_save_dependent_files_0;
11899         uint32_t _ptr_monitor_name;
11900         TALLOC_CTX *_mem_save_monitor_name_0;
11901         uint32_t _ptr_default_datatype;
11902         TALLOC_CTX *_mem_save_default_datatype_0;
11903         uint32_t _ptr_previous_names;
11904         TALLOC_CTX *_mem_save_previous_names_0;
11905         if (ndr_flags & NDR_SCALARS) {
11906                 NDR_CHECK(ndr_pull_align(ndr, 5));
11907                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11908                 {
11909                         uint32_t _flags_save_string = ndr->flags;
11910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11911                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11912                         if (_ptr_driver_name) {
11913                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11914                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11915                         } else {
11916                                 r->driver_name = NULL;
11917                         }
11918                         ndr->flags = _flags_save_string;
11919                 }
11920                 {
11921                         uint32_t _flags_save_string = ndr->flags;
11922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11923                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11924                         if (_ptr_architecture) {
11925                                 NDR_PULL_ALLOC(ndr, r->architecture);
11926                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11927                         } else {
11928                                 r->architecture = NULL;
11929                         }
11930                         ndr->flags = _flags_save_string;
11931                 }
11932                 {
11933                         uint32_t _flags_save_string = ndr->flags;
11934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11935                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11936                         if (_ptr_driver_path) {
11937                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11938                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11939                         } else {
11940                                 r->driver_path = NULL;
11941                         }
11942                         ndr->flags = _flags_save_string;
11943                 }
11944                 {
11945                         uint32_t _flags_save_string = ndr->flags;
11946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11947                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11948                         if (_ptr_data_file) {
11949                                 NDR_PULL_ALLOC(ndr, r->data_file);
11950                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11951                         } else {
11952                                 r->data_file = NULL;
11953                         }
11954                         ndr->flags = _flags_save_string;
11955                 }
11956                 {
11957                         uint32_t _flags_save_string = ndr->flags;
11958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11959                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11960                         if (_ptr_config_file) {
11961                                 NDR_PULL_ALLOC(ndr, r->config_file);
11962                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11963                         } else {
11964                                 r->config_file = NULL;
11965                         }
11966                         ndr->flags = _flags_save_string;
11967                 }
11968                 {
11969                         uint32_t _flags_save_string = ndr->flags;
11970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11971                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11972                         if (_ptr_help_file) {
11973                                 NDR_PULL_ALLOC(ndr, r->help_file);
11974                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11975                         } else {
11976                                 r->help_file = NULL;
11977                         }
11978                         ndr->flags = _flags_save_string;
11979                 }
11980                 {
11981                         uint32_t _flags_save_string_array = ndr->flags;
11982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11983                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11984                         if (_ptr_dependent_files) {
11985                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11986                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11987                         } else {
11988                                 r->dependent_files = NULL;
11989                         }
11990                         ndr->flags = _flags_save_string_array;
11991                 }
11992                 {
11993                         uint32_t _flags_save_string = ndr->flags;
11994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11995                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11996                         if (_ptr_monitor_name) {
11997                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11998                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11999                         } else {
12000                                 r->monitor_name = NULL;
12001                         }
12002                         ndr->flags = _flags_save_string;
12003                 }
12004                 {
12005                         uint32_t _flags_save_string = ndr->flags;
12006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12007                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12008                         if (_ptr_default_datatype) {
12009                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12010                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12011                         } else {
12012                                 r->default_datatype = NULL;
12013                         }
12014                         ndr->flags = _flags_save_string;
12015                 }
12016                 {
12017                         uint32_t _flags_save_string_array = ndr->flags;
12018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12019                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12020                         if (_ptr_previous_names) {
12021                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12022                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12023                         } else {
12024                                 r->previous_names = NULL;
12025                         }
12026                         ndr->flags = _flags_save_string_array;
12027                 }
12028                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12029         }
12030         if (ndr_flags & NDR_BUFFERS) {
12031                 {
12032                         uint32_t _flags_save_string = ndr->flags;
12033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12034                         if (r->driver_name) {
12035                                 uint32_t _relative_save_offset;
12036                                 _relative_save_offset = ndr->offset;
12037                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12038                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12039                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12040                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12041                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12042                                 ndr->offset = _relative_save_offset;
12043                         }
12044                         ndr->flags = _flags_save_string;
12045                 }
12046                 {
12047                         uint32_t _flags_save_string = ndr->flags;
12048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12049                         if (r->architecture) {
12050                                 uint32_t _relative_save_offset;
12051                                 _relative_save_offset = ndr->offset;
12052                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12053                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12054                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12055                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12056                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12057                                 ndr->offset = _relative_save_offset;
12058                         }
12059                         ndr->flags = _flags_save_string;
12060                 }
12061                 {
12062                         uint32_t _flags_save_string = ndr->flags;
12063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12064                         if (r->driver_path) {
12065                                 uint32_t _relative_save_offset;
12066                                 _relative_save_offset = ndr->offset;
12067                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12068                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12069                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12070                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12071                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12072                                 ndr->offset = _relative_save_offset;
12073                         }
12074                         ndr->flags = _flags_save_string;
12075                 }
12076                 {
12077                         uint32_t _flags_save_string = ndr->flags;
12078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12079                         if (r->data_file) {
12080                                 uint32_t _relative_save_offset;
12081                                 _relative_save_offset = ndr->offset;
12082                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12083                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12084                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12085                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12086                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12087                                 ndr->offset = _relative_save_offset;
12088                         }
12089                         ndr->flags = _flags_save_string;
12090                 }
12091                 {
12092                         uint32_t _flags_save_string = ndr->flags;
12093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12094                         if (r->config_file) {
12095                                 uint32_t _relative_save_offset;
12096                                 _relative_save_offset = ndr->offset;
12097                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12098                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12099                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12100                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12101                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12102                                 ndr->offset = _relative_save_offset;
12103                         }
12104                         ndr->flags = _flags_save_string;
12105                 }
12106                 {
12107                         uint32_t _flags_save_string = ndr->flags;
12108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12109                         if (r->help_file) {
12110                                 uint32_t _relative_save_offset;
12111                                 _relative_save_offset = ndr->offset;
12112                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12113                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12114                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12115                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12116                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12117                                 ndr->offset = _relative_save_offset;
12118                         }
12119                         ndr->flags = _flags_save_string;
12120                 }
12121                 {
12122                         uint32_t _flags_save_string_array = ndr->flags;
12123                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12124                         if (r->dependent_files) {
12125                                 uint32_t _relative_save_offset;
12126                                 _relative_save_offset = ndr->offset;
12127                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12128                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12129                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12130                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12131                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12132                                 ndr->offset = _relative_save_offset;
12133                         }
12134                         ndr->flags = _flags_save_string_array;
12135                 }
12136                 {
12137                         uint32_t _flags_save_string = ndr->flags;
12138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12139                         if (r->monitor_name) {
12140                                 uint32_t _relative_save_offset;
12141                                 _relative_save_offset = ndr->offset;
12142                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12143                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12144                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12145                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12146                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12147                                 ndr->offset = _relative_save_offset;
12148                         }
12149                         ndr->flags = _flags_save_string;
12150                 }
12151                 {
12152                         uint32_t _flags_save_string = ndr->flags;
12153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12154                         if (r->default_datatype) {
12155                                 uint32_t _relative_save_offset;
12156                                 _relative_save_offset = ndr->offset;
12157                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12158                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12159                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12160                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12161                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12162                                 ndr->offset = _relative_save_offset;
12163                         }
12164                         ndr->flags = _flags_save_string;
12165                 }
12166                 {
12167                         uint32_t _flags_save_string_array = ndr->flags;
12168                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12169                         if (r->previous_names) {
12170                                 uint32_t _relative_save_offset;
12171                                 _relative_save_offset = ndr->offset;
12172                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12173                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12174                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12175                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12176                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12177                                 ndr->offset = _relative_save_offset;
12178                         }
12179                         ndr->flags = _flags_save_string_array;
12180                 }
12181         }
12182         return NDR_ERR_SUCCESS;
12183 }
12184
12185 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
12186 {
12187         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
12188         ndr->depth++;
12189         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12190         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12191         ndr->depth++;
12192         if (r->driver_name) {
12193                 ndr_print_string(ndr, "driver_name", r->driver_name);
12194         }
12195         ndr->depth--;
12196         ndr_print_ptr(ndr, "architecture", r->architecture);
12197         ndr->depth++;
12198         if (r->architecture) {
12199                 ndr_print_string(ndr, "architecture", r->architecture);
12200         }
12201         ndr->depth--;
12202         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12203         ndr->depth++;
12204         if (r->driver_path) {
12205                 ndr_print_string(ndr, "driver_path", r->driver_path);
12206         }
12207         ndr->depth--;
12208         ndr_print_ptr(ndr, "data_file", r->data_file);
12209         ndr->depth++;
12210         if (r->data_file) {
12211                 ndr_print_string(ndr, "data_file", r->data_file);
12212         }
12213         ndr->depth--;
12214         ndr_print_ptr(ndr, "config_file", r->config_file);
12215         ndr->depth++;
12216         if (r->config_file) {
12217                 ndr_print_string(ndr, "config_file", r->config_file);
12218         }
12219         ndr->depth--;
12220         ndr_print_ptr(ndr, "help_file", r->help_file);
12221         ndr->depth++;
12222         if (r->help_file) {
12223                 ndr_print_string(ndr, "help_file", r->help_file);
12224         }
12225         ndr->depth--;
12226         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12227         ndr->depth++;
12228         if (r->dependent_files) {
12229                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12230         }
12231         ndr->depth--;
12232         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12233         ndr->depth++;
12234         if (r->monitor_name) {
12235                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12236         }
12237         ndr->depth--;
12238         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12239         ndr->depth++;
12240         if (r->default_datatype) {
12241                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12242         }
12243         ndr->depth--;
12244         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12245         ndr->depth++;
12246         if (r->previous_names) {
12247                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12248         }
12249         ndr->depth--;
12250         ndr->depth--;
12251 }
12252
12253 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12254 {
12255         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12256 }
12257
12258 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12259 {
12260         if (ndr_flags & NDR_SCALARS) {
12261                 NDR_CHECK(ndr_push_align(ndr, 5));
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|LIBNDR_FLAG_ALIGN2);
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|LIBNDR_FLAG_ALIGN2);
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|LIBNDR_FLAG_ALIGN2);
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|LIBNDR_FLAG_ALIGN2);
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|LIBNDR_FLAG_ALIGN2);
12290                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12291                         ndr->flags = _flags_save_string;
12292                 }
12293                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12296                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12297         }
12298         if (ndr_flags & NDR_BUFFERS) {
12299                 {
12300                         uint32_t _flags_save_string = ndr->flags;
12301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12302                         if (r->driver_name) {
12303                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12304                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12305                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12306                         }
12307                         ndr->flags = _flags_save_string;
12308                 }
12309                 {
12310                         uint32_t _flags_save_string = ndr->flags;
12311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12312                         if (r->architecture) {
12313                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12315                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12316                         }
12317                         ndr->flags = _flags_save_string;
12318                 }
12319                 {
12320                         uint32_t _flags_save_string = ndr->flags;
12321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12322                         if (r->driver_path) {
12323                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12324                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12325                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12326                         }
12327                         ndr->flags = _flags_save_string;
12328                 }
12329                 {
12330                         uint32_t _flags_save_string = ndr->flags;
12331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12332                         if (r->data_file) {
12333                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12334                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12335                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12336                         }
12337                         ndr->flags = _flags_save_string;
12338                 }
12339                 {
12340                         uint32_t _flags_save_string = ndr->flags;
12341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12342                         if (r->config_file) {
12343                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12344                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12345                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12346                         }
12347                         ndr->flags = _flags_save_string;
12348                 }
12349         }
12350         return NDR_ERR_SUCCESS;
12351 }
12352
12353 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12354 {
12355         uint32_t _ptr_driver_name;
12356         TALLOC_CTX *_mem_save_driver_name_0;
12357         uint32_t _ptr_architecture;
12358         TALLOC_CTX *_mem_save_architecture_0;
12359         uint32_t _ptr_driver_path;
12360         TALLOC_CTX *_mem_save_driver_path_0;
12361         uint32_t _ptr_data_file;
12362         TALLOC_CTX *_mem_save_data_file_0;
12363         uint32_t _ptr_config_file;
12364         TALLOC_CTX *_mem_save_config_file_0;
12365         if (ndr_flags & NDR_SCALARS) {
12366                 NDR_CHECK(ndr_pull_align(ndr, 5));
12367                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12368                 {
12369                         uint32_t _flags_save_string = ndr->flags;
12370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12371                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12372                         if (_ptr_driver_name) {
12373                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12374                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12375                         } else {
12376                                 r->driver_name = NULL;
12377                         }
12378                         ndr->flags = _flags_save_string;
12379                 }
12380                 {
12381                         uint32_t _flags_save_string = ndr->flags;
12382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12383                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12384                         if (_ptr_architecture) {
12385                                 NDR_PULL_ALLOC(ndr, r->architecture);
12386                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12387                         } else {
12388                                 r->architecture = NULL;
12389                         }
12390                         ndr->flags = _flags_save_string;
12391                 }
12392                 {
12393                         uint32_t _flags_save_string = ndr->flags;
12394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12395                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12396                         if (_ptr_driver_path) {
12397                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12398                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12399                         } else {
12400                                 r->driver_path = NULL;
12401                         }
12402                         ndr->flags = _flags_save_string;
12403                 }
12404                 {
12405                         uint32_t _flags_save_string = ndr->flags;
12406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12407                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12408                         if (_ptr_data_file) {
12409                                 NDR_PULL_ALLOC(ndr, r->data_file);
12410                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12411                         } else {
12412                                 r->data_file = NULL;
12413                         }
12414                         ndr->flags = _flags_save_string;
12415                 }
12416                 {
12417                         uint32_t _flags_save_string = ndr->flags;
12418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12419                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12420                         if (_ptr_config_file) {
12421                                 NDR_PULL_ALLOC(ndr, r->config_file);
12422                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12423                         } else {
12424                                 r->config_file = NULL;
12425                         }
12426                         ndr->flags = _flags_save_string;
12427                 }
12428                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12431                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12432         }
12433         if (ndr_flags & NDR_BUFFERS) {
12434                 {
12435                         uint32_t _flags_save_string = ndr->flags;
12436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12437                         if (r->driver_name) {
12438                                 uint32_t _relative_save_offset;
12439                                 _relative_save_offset = ndr->offset;
12440                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12441                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12442                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12443                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12444                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12445                                 ndr->offset = _relative_save_offset;
12446                         }
12447                         ndr->flags = _flags_save_string;
12448                 }
12449                 {
12450                         uint32_t _flags_save_string = ndr->flags;
12451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12452                         if (r->architecture) {
12453                                 uint32_t _relative_save_offset;
12454                                 _relative_save_offset = ndr->offset;
12455                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12456                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12457                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12458                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12459                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12460                                 ndr->offset = _relative_save_offset;
12461                         }
12462                         ndr->flags = _flags_save_string;
12463                 }
12464                 {
12465                         uint32_t _flags_save_string = ndr->flags;
12466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12467                         if (r->driver_path) {
12468                                 uint32_t _relative_save_offset;
12469                                 _relative_save_offset = ndr->offset;
12470                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12471                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12472                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12473                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12474                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12475                                 ndr->offset = _relative_save_offset;
12476                         }
12477                         ndr->flags = _flags_save_string;
12478                 }
12479                 {
12480                         uint32_t _flags_save_string = ndr->flags;
12481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12482                         if (r->data_file) {
12483                                 uint32_t _relative_save_offset;
12484                                 _relative_save_offset = ndr->offset;
12485                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12486                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12487                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12488                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12489                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12490                                 ndr->offset = _relative_save_offset;
12491                         }
12492                         ndr->flags = _flags_save_string;
12493                 }
12494                 {
12495                         uint32_t _flags_save_string = ndr->flags;
12496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12497                         if (r->config_file) {
12498                                 uint32_t _relative_save_offset;
12499                                 _relative_save_offset = ndr->offset;
12500                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12501                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12502                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12503                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12504                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12505                                 ndr->offset = _relative_save_offset;
12506                         }
12507                         ndr->flags = _flags_save_string;
12508                 }
12509         }
12510         return NDR_ERR_SUCCESS;
12511 }
12512
12513 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12514 {
12515         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12516         ndr->depth++;
12517         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12518         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12519         ndr->depth++;
12520         if (r->driver_name) {
12521                 ndr_print_string(ndr, "driver_name", r->driver_name);
12522         }
12523         ndr->depth--;
12524         ndr_print_ptr(ndr, "architecture", r->architecture);
12525         ndr->depth++;
12526         if (r->architecture) {
12527                 ndr_print_string(ndr, "architecture", r->architecture);
12528         }
12529         ndr->depth--;
12530         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12531         ndr->depth++;
12532         if (r->driver_path) {
12533                 ndr_print_string(ndr, "driver_path", r->driver_path);
12534         }
12535         ndr->depth--;
12536         ndr_print_ptr(ndr, "data_file", r->data_file);
12537         ndr->depth++;
12538         if (r->data_file) {
12539                 ndr_print_string(ndr, "data_file", r->data_file);
12540         }
12541         ndr->depth--;
12542         ndr_print_ptr(ndr, "config_file", r->config_file);
12543         ndr->depth++;
12544         if (r->config_file) {
12545                 ndr_print_string(ndr, "config_file", r->config_file);
12546         }
12547         ndr->depth--;
12548         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12549         ndr_print_uint32(ndr, "config_version", r->config_version);
12550         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12551         ndr->depth--;
12552 }
12553
12554 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12555 {
12556         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12557 }
12558
12559 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12560 {
12561         if (ndr_flags & NDR_SCALARS) {
12562                 NDR_CHECK(ndr_push_align(ndr, 8));
12563                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12564                 {
12565                         uint32_t _flags_save_string = ndr->flags;
12566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12567                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12568                         ndr->flags = _flags_save_string;
12569                 }
12570                 {
12571                         uint32_t _flags_save_string = ndr->flags;
12572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12573                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12574                         ndr->flags = _flags_save_string;
12575                 }
12576                 {
12577                         uint32_t _flags_save_string = ndr->flags;
12578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12580                         ndr->flags = _flags_save_string;
12581                 }
12582                 {
12583                         uint32_t _flags_save_string = ndr->flags;
12584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12586                         ndr->flags = _flags_save_string;
12587                 }
12588                 {
12589                         uint32_t _flags_save_string = ndr->flags;
12590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12591                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12592                         ndr->flags = _flags_save_string;
12593                 }
12594                 {
12595                         uint32_t _flags_save_string = ndr->flags;
12596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12597                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12598                         ndr->flags = _flags_save_string;
12599                 }
12600                 {
12601                         uint32_t _flags_save_string_array = ndr->flags;
12602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12603                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12604                         ndr->flags = _flags_save_string_array;
12605                 }
12606                 {
12607                         uint32_t _flags_save_string = ndr->flags;
12608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12610                         ndr->flags = _flags_save_string;
12611                 }
12612                 {
12613                         uint32_t _flags_save_string = ndr->flags;
12614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12615                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12616                         ndr->flags = _flags_save_string;
12617                 }
12618                 {
12619                         uint32_t _flags_save_string_array = ndr->flags;
12620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12621                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12622                         ndr->flags = _flags_save_string_array;
12623                 }
12624                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12625                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12626                 {
12627                         uint32_t _flags_save_string = ndr->flags;
12628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12629                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12630                         ndr->flags = _flags_save_string;
12631                 }
12632                 {
12633                         uint32_t _flags_save_string = ndr->flags;
12634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12635                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
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|LIBNDR_FLAG_ALIGN2);
12641                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12642                         ndr->flags = _flags_save_string;
12643                 }
12644                 {
12645                         uint32_t _flags_save_string = ndr->flags;
12646                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12647                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12648                         ndr->flags = _flags_save_string;
12649                 }
12650                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12651         }
12652         if (ndr_flags & NDR_BUFFERS) {
12653                 {
12654                         uint32_t _flags_save_string = ndr->flags;
12655                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12656                         if (r->driver_name) {
12657                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12658                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12659                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12660                         }
12661                         ndr->flags = _flags_save_string;
12662                 }
12663                 {
12664                         uint32_t _flags_save_string = ndr->flags;
12665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12666                         if (r->architecture) {
12667                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12668                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12669                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12670                         }
12671                         ndr->flags = _flags_save_string;
12672                 }
12673                 {
12674                         uint32_t _flags_save_string = ndr->flags;
12675                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12676                         if (r->driver_path) {
12677                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12678                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12679                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12680                         }
12681                         ndr->flags = _flags_save_string;
12682                 }
12683                 {
12684                         uint32_t _flags_save_string = ndr->flags;
12685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12686                         if (r->data_file) {
12687                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12688                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12689                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12690                         }
12691                         ndr->flags = _flags_save_string;
12692                 }
12693                 {
12694                         uint32_t _flags_save_string = ndr->flags;
12695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12696                         if (r->config_file) {
12697                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12698                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12699                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12700                         }
12701                         ndr->flags = _flags_save_string;
12702                 }
12703                 {
12704                         uint32_t _flags_save_string = ndr->flags;
12705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12706                         if (r->help_file) {
12707                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
12708                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12709                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
12710                         }
12711                         ndr->flags = _flags_save_string;
12712                 }
12713                 {
12714                         uint32_t _flags_save_string_array = ndr->flags;
12715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12716                         if (r->dependent_files) {
12717                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12718                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12719                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12720                         }
12721                         ndr->flags = _flags_save_string_array;
12722                 }
12723                 {
12724                         uint32_t _flags_save_string = ndr->flags;
12725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12726                         if (r->monitor_name) {
12727                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12728                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12729                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12730                         }
12731                         ndr->flags = _flags_save_string;
12732                 }
12733                 {
12734                         uint32_t _flags_save_string = ndr->flags;
12735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12736                         if (r->default_datatype) {
12737                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12738                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12739                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12740                         }
12741                         ndr->flags = _flags_save_string;
12742                 }
12743                 {
12744                         uint32_t _flags_save_string_array = ndr->flags;
12745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12746                         if (r->previous_names) {
12747                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12748                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12749                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12750                         }
12751                         ndr->flags = _flags_save_string_array;
12752                 }
12753                 {
12754                         uint32_t _flags_save_string = ndr->flags;
12755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12756                         if (r->manufacturer_name) {
12757                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
12758                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12759                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
12760                         }
12761                         ndr->flags = _flags_save_string;
12762                 }
12763                 {
12764                         uint32_t _flags_save_string = ndr->flags;
12765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12766                         if (r->manufacturer_url) {
12767                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
12768                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12769                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
12770                         }
12771                         ndr->flags = _flags_save_string;
12772                 }
12773                 {
12774                         uint32_t _flags_save_string = ndr->flags;
12775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12776                         if (r->hardware_id) {
12777                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
12778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12779                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
12780                         }
12781                         ndr->flags = _flags_save_string;
12782                 }
12783                 {
12784                         uint32_t _flags_save_string = ndr->flags;
12785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12786                         if (r->provider) {
12787                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
12788                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12789                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
12790                         }
12791                         ndr->flags = _flags_save_string;
12792                 }
12793         }
12794         return NDR_ERR_SUCCESS;
12795 }
12796
12797 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12798 {
12799         uint32_t _ptr_driver_name;
12800         TALLOC_CTX *_mem_save_driver_name_0;
12801         uint32_t _ptr_architecture;
12802         TALLOC_CTX *_mem_save_architecture_0;
12803         uint32_t _ptr_driver_path;
12804         TALLOC_CTX *_mem_save_driver_path_0;
12805         uint32_t _ptr_data_file;
12806         TALLOC_CTX *_mem_save_data_file_0;
12807         uint32_t _ptr_config_file;
12808         TALLOC_CTX *_mem_save_config_file_0;
12809         uint32_t _ptr_help_file;
12810         TALLOC_CTX *_mem_save_help_file_0;
12811         uint32_t _ptr_dependent_files;
12812         TALLOC_CTX *_mem_save_dependent_files_0;
12813         uint32_t _ptr_monitor_name;
12814         TALLOC_CTX *_mem_save_monitor_name_0;
12815         uint32_t _ptr_default_datatype;
12816         TALLOC_CTX *_mem_save_default_datatype_0;
12817         uint32_t _ptr_previous_names;
12818         TALLOC_CTX *_mem_save_previous_names_0;
12819         uint32_t _ptr_manufacturer_name;
12820         TALLOC_CTX *_mem_save_manufacturer_name_0;
12821         uint32_t _ptr_manufacturer_url;
12822         TALLOC_CTX *_mem_save_manufacturer_url_0;
12823         uint32_t _ptr_hardware_id;
12824         TALLOC_CTX *_mem_save_hardware_id_0;
12825         uint32_t _ptr_provider;
12826         TALLOC_CTX *_mem_save_provider_0;
12827         if (ndr_flags & NDR_SCALARS) {
12828                 NDR_CHECK(ndr_pull_align(ndr, 8));
12829                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12830                 {
12831                         uint32_t _flags_save_string = ndr->flags;
12832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12833                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12834                         if (_ptr_driver_name) {
12835                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12836                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12837                         } else {
12838                                 r->driver_name = NULL;
12839                         }
12840                         ndr->flags = _flags_save_string;
12841                 }
12842                 {
12843                         uint32_t _flags_save_string = ndr->flags;
12844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12845                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12846                         if (_ptr_architecture) {
12847                                 NDR_PULL_ALLOC(ndr, r->architecture);
12848                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12849                         } else {
12850                                 r->architecture = NULL;
12851                         }
12852                         ndr->flags = _flags_save_string;
12853                 }
12854                 {
12855                         uint32_t _flags_save_string = ndr->flags;
12856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12857                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12858                         if (_ptr_driver_path) {
12859                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12860                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12861                         } else {
12862                                 r->driver_path = NULL;
12863                         }
12864                         ndr->flags = _flags_save_string;
12865                 }
12866                 {
12867                         uint32_t _flags_save_string = ndr->flags;
12868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12869                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12870                         if (_ptr_data_file) {
12871                                 NDR_PULL_ALLOC(ndr, r->data_file);
12872                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12873                         } else {
12874                                 r->data_file = NULL;
12875                         }
12876                         ndr->flags = _flags_save_string;
12877                 }
12878                 {
12879                         uint32_t _flags_save_string = ndr->flags;
12880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12881                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12882                         if (_ptr_config_file) {
12883                                 NDR_PULL_ALLOC(ndr, r->config_file);
12884                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12885                         } else {
12886                                 r->config_file = NULL;
12887                         }
12888                         ndr->flags = _flags_save_string;
12889                 }
12890                 {
12891                         uint32_t _flags_save_string = ndr->flags;
12892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12893                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12894                         if (_ptr_help_file) {
12895                                 NDR_PULL_ALLOC(ndr, r->help_file);
12896                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12897                         } else {
12898                                 r->help_file = NULL;
12899                         }
12900                         ndr->flags = _flags_save_string;
12901                 }
12902                 {
12903                         uint32_t _flags_save_string_array = ndr->flags;
12904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12905                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12906                         if (_ptr_dependent_files) {
12907                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12908                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12909                         } else {
12910                                 r->dependent_files = NULL;
12911                         }
12912                         ndr->flags = _flags_save_string_array;
12913                 }
12914                 {
12915                         uint32_t _flags_save_string = ndr->flags;
12916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12917                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12918                         if (_ptr_monitor_name) {
12919                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12920                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12921                         } else {
12922                                 r->monitor_name = NULL;
12923                         }
12924                         ndr->flags = _flags_save_string;
12925                 }
12926                 {
12927                         uint32_t _flags_save_string = ndr->flags;
12928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12929                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12930                         if (_ptr_default_datatype) {
12931                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12932                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12933                         } else {
12934                                 r->default_datatype = NULL;
12935                         }
12936                         ndr->flags = _flags_save_string;
12937                 }
12938                 {
12939                         uint32_t _flags_save_string_array = ndr->flags;
12940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12941                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12942                         if (_ptr_previous_names) {
12943                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12944                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12945                         } else {
12946                                 r->previous_names = NULL;
12947                         }
12948                         ndr->flags = _flags_save_string_array;
12949                 }
12950                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12951                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12952                 {
12953                         uint32_t _flags_save_string = ndr->flags;
12954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12955                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12956                         if (_ptr_manufacturer_name) {
12957                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12958                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12959                         } else {
12960                                 r->manufacturer_name = NULL;
12961                         }
12962                         ndr->flags = _flags_save_string;
12963                 }
12964                 {
12965                         uint32_t _flags_save_string = ndr->flags;
12966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12967                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12968                         if (_ptr_manufacturer_url) {
12969                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12970                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12971                         } else {
12972                                 r->manufacturer_url = NULL;
12973                         }
12974                         ndr->flags = _flags_save_string;
12975                 }
12976                 {
12977                         uint32_t _flags_save_string = ndr->flags;
12978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12979                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12980                         if (_ptr_hardware_id) {
12981                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12982                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12983                         } else {
12984                                 r->hardware_id = NULL;
12985                         }
12986                         ndr->flags = _flags_save_string;
12987                 }
12988                 {
12989                         uint32_t _flags_save_string = ndr->flags;
12990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12991                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12992                         if (_ptr_provider) {
12993                                 NDR_PULL_ALLOC(ndr, r->provider);
12994                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12995                         } else {
12996                                 r->provider = NULL;
12997                         }
12998                         ndr->flags = _flags_save_string;
12999                 }
13000                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13001         }
13002         if (ndr_flags & NDR_BUFFERS) {
13003                 {
13004                         uint32_t _flags_save_string = ndr->flags;
13005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13006                         if (r->driver_name) {
13007                                 uint32_t _relative_save_offset;
13008                                 _relative_save_offset = ndr->offset;
13009                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13010                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13011                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13012                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13013                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13014                                 ndr->offset = _relative_save_offset;
13015                         }
13016                         ndr->flags = _flags_save_string;
13017                 }
13018                 {
13019                         uint32_t _flags_save_string = ndr->flags;
13020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13021                         if (r->architecture) {
13022                                 uint32_t _relative_save_offset;
13023                                 _relative_save_offset = ndr->offset;
13024                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13025                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13026                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13027                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13028                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13029                                 ndr->offset = _relative_save_offset;
13030                         }
13031                         ndr->flags = _flags_save_string;
13032                 }
13033                 {
13034                         uint32_t _flags_save_string = ndr->flags;
13035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13036                         if (r->driver_path) {
13037                                 uint32_t _relative_save_offset;
13038                                 _relative_save_offset = ndr->offset;
13039                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13040                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13041                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13042                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13043                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13044                                 ndr->offset = _relative_save_offset;
13045                         }
13046                         ndr->flags = _flags_save_string;
13047                 }
13048                 {
13049                         uint32_t _flags_save_string = ndr->flags;
13050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13051                         if (r->data_file) {
13052                                 uint32_t _relative_save_offset;
13053                                 _relative_save_offset = ndr->offset;
13054                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13055                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13056                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13057                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13058                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13059                                 ndr->offset = _relative_save_offset;
13060                         }
13061                         ndr->flags = _flags_save_string;
13062                 }
13063                 {
13064                         uint32_t _flags_save_string = ndr->flags;
13065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13066                         if (r->config_file) {
13067                                 uint32_t _relative_save_offset;
13068                                 _relative_save_offset = ndr->offset;
13069                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13070                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13071                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13072                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13073                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13074                                 ndr->offset = _relative_save_offset;
13075                         }
13076                         ndr->flags = _flags_save_string;
13077                 }
13078                 {
13079                         uint32_t _flags_save_string = ndr->flags;
13080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13081                         if (r->help_file) {
13082                                 uint32_t _relative_save_offset;
13083                                 _relative_save_offset = ndr->offset;
13084                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13085                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13086                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13087                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13088                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13089                                 ndr->offset = _relative_save_offset;
13090                         }
13091                         ndr->flags = _flags_save_string;
13092                 }
13093                 {
13094                         uint32_t _flags_save_string_array = ndr->flags;
13095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13096                         if (r->dependent_files) {
13097                                 uint32_t _relative_save_offset;
13098                                 _relative_save_offset = ndr->offset;
13099                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13100                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13101                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13102                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13103                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13104                                 ndr->offset = _relative_save_offset;
13105                         }
13106                         ndr->flags = _flags_save_string_array;
13107                 }
13108                 {
13109                         uint32_t _flags_save_string = ndr->flags;
13110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13111                         if (r->monitor_name) {
13112                                 uint32_t _relative_save_offset;
13113                                 _relative_save_offset = ndr->offset;
13114                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13115                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13116                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13117                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13118                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13119                                 ndr->offset = _relative_save_offset;
13120                         }
13121                         ndr->flags = _flags_save_string;
13122                 }
13123                 {
13124                         uint32_t _flags_save_string = ndr->flags;
13125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13126                         if (r->default_datatype) {
13127                                 uint32_t _relative_save_offset;
13128                                 _relative_save_offset = ndr->offset;
13129                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13130                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13131                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13132                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13133                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13134                                 ndr->offset = _relative_save_offset;
13135                         }
13136                         ndr->flags = _flags_save_string;
13137                 }
13138                 {
13139                         uint32_t _flags_save_string_array = ndr->flags;
13140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13141                         if (r->previous_names) {
13142                                 uint32_t _relative_save_offset;
13143                                 _relative_save_offset = ndr->offset;
13144                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13145                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13146                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13147                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13148                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13149                                 ndr->offset = _relative_save_offset;
13150                         }
13151                         ndr->flags = _flags_save_string_array;
13152                 }
13153                 {
13154                         uint32_t _flags_save_string = ndr->flags;
13155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13156                         if (r->manufacturer_name) {
13157                                 uint32_t _relative_save_offset;
13158                                 _relative_save_offset = ndr->offset;
13159                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13160                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13161                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13162                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13163                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13164                                 ndr->offset = _relative_save_offset;
13165                         }
13166                         ndr->flags = _flags_save_string;
13167                 }
13168                 {
13169                         uint32_t _flags_save_string = ndr->flags;
13170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13171                         if (r->manufacturer_url) {
13172                                 uint32_t _relative_save_offset;
13173                                 _relative_save_offset = ndr->offset;
13174                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13175                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13176                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13177                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13178                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13179                                 ndr->offset = _relative_save_offset;
13180                         }
13181                         ndr->flags = _flags_save_string;
13182                 }
13183                 {
13184                         uint32_t _flags_save_string = ndr->flags;
13185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13186                         if (r->hardware_id) {
13187                                 uint32_t _relative_save_offset;
13188                                 _relative_save_offset = ndr->offset;
13189                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13190                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13191                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13192                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13193                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13194                                 ndr->offset = _relative_save_offset;
13195                         }
13196                         ndr->flags = _flags_save_string;
13197                 }
13198                 {
13199                         uint32_t _flags_save_string = ndr->flags;
13200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13201                         if (r->provider) {
13202                                 uint32_t _relative_save_offset;
13203                                 _relative_save_offset = ndr->offset;
13204                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13205                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13206                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13207                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13208                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13209                                 ndr->offset = _relative_save_offset;
13210                         }
13211                         ndr->flags = _flags_save_string;
13212                 }
13213         }
13214         return NDR_ERR_SUCCESS;
13215 }
13216
13217 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13218 {
13219         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13220         ndr->depth++;
13221         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13222         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13223         ndr->depth++;
13224         if (r->driver_name) {
13225                 ndr_print_string(ndr, "driver_name", r->driver_name);
13226         }
13227         ndr->depth--;
13228         ndr_print_ptr(ndr, "architecture", r->architecture);
13229         ndr->depth++;
13230         if (r->architecture) {
13231                 ndr_print_string(ndr, "architecture", r->architecture);
13232         }
13233         ndr->depth--;
13234         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13235         ndr->depth++;
13236         if (r->driver_path) {
13237                 ndr_print_string(ndr, "driver_path", r->driver_path);
13238         }
13239         ndr->depth--;
13240         ndr_print_ptr(ndr, "data_file", r->data_file);
13241         ndr->depth++;
13242         if (r->data_file) {
13243                 ndr_print_string(ndr, "data_file", r->data_file);
13244         }
13245         ndr->depth--;
13246         ndr_print_ptr(ndr, "config_file", r->config_file);
13247         ndr->depth++;
13248         if (r->config_file) {
13249                 ndr_print_string(ndr, "config_file", r->config_file);
13250         }
13251         ndr->depth--;
13252         ndr_print_ptr(ndr, "help_file", r->help_file);
13253         ndr->depth++;
13254         if (r->help_file) {
13255                 ndr_print_string(ndr, "help_file", r->help_file);
13256         }
13257         ndr->depth--;
13258         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13259         ndr->depth++;
13260         if (r->dependent_files) {
13261                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13262         }
13263         ndr->depth--;
13264         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13265         ndr->depth++;
13266         if (r->monitor_name) {
13267                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13268         }
13269         ndr->depth--;
13270         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13271         ndr->depth++;
13272         if (r->default_datatype) {
13273                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13274         }
13275         ndr->depth--;
13276         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13277         ndr->depth++;
13278         if (r->previous_names) {
13279                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13280         }
13281         ndr->depth--;
13282         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13283         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13284         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13285         ndr->depth++;
13286         if (r->manufacturer_name) {
13287                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13288         }
13289         ndr->depth--;
13290         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13291         ndr->depth++;
13292         if (r->manufacturer_url) {
13293                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13294         }
13295         ndr->depth--;
13296         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13297         ndr->depth++;
13298         if (r->hardware_id) {
13299                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13300         }
13301         ndr->depth--;
13302         ndr_print_ptr(ndr, "provider", r->provider);
13303         ndr->depth++;
13304         if (r->provider) {
13305                 ndr_print_string(ndr, "provider", r->provider);
13306         }
13307         ndr->depth--;
13308         ndr->depth--;
13309 }
13310
13311 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13312 {
13313         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13314 }
13315
13316 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo7 *r)
13317 {
13318         if (ndr_flags & NDR_SCALARS) {
13319                 NDR_CHECK(ndr_push_align(ndr, 5));
13320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13321                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13322                 {
13323                         uint32_t _flags_save_string = ndr->flags;
13324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13325                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13326                         ndr->flags = _flags_save_string;
13327                 }
13328                 {
13329                         uint32_t _flags_save_string = ndr->flags;
13330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13331                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_name));
13332                         ndr->flags = _flags_save_string;
13333                 }
13334                 {
13335                         uint32_t _flags_save_string = ndr->flags;
13336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13337                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->install_source_root));
13338                         ndr->flags = _flags_save_string;
13339                 }
13340                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13341         }
13342         if (ndr_flags & NDR_BUFFERS) {
13343                 {
13344                         uint32_t _flags_save_string = ndr->flags;
13345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13346                         if (r->driver_name) {
13347                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13348                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13349                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13350                         }
13351                         ndr->flags = _flags_save_string;
13352                 }
13353                 {
13354                         uint32_t _flags_save_string = ndr->flags;
13355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13356                         if (r->inf_name) {
13357                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_name));
13358                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_name));
13359                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_name));
13360                         }
13361                         ndr->flags = _flags_save_string;
13362                 }
13363                 {
13364                         uint32_t _flags_save_string = ndr->flags;
13365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13366                         if (r->install_source_root) {
13367                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->install_source_root));
13368                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->install_source_root));
13369                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->install_source_root));
13370                         }
13371                         ndr->flags = _flags_save_string;
13372                 }
13373         }
13374         return NDR_ERR_SUCCESS;
13375 }
13376
13377 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo7 *r)
13378 {
13379         uint32_t _ptr_driver_name;
13380         TALLOC_CTX *_mem_save_driver_name_0;
13381         uint32_t _ptr_inf_name;
13382         TALLOC_CTX *_mem_save_inf_name_0;
13383         uint32_t _ptr_install_source_root;
13384         TALLOC_CTX *_mem_save_install_source_root_0;
13385         if (ndr_flags & NDR_SCALARS) {
13386                 NDR_CHECK(ndr_pull_align(ndr, 5));
13387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13388                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13389                 {
13390                         uint32_t _flags_save_string = ndr->flags;
13391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13392                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13393                         if (_ptr_driver_name) {
13394                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13395                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13396                         } else {
13397                                 r->driver_name = NULL;
13398                         }
13399                         ndr->flags = _flags_save_string;
13400                 }
13401                 {
13402                         uint32_t _flags_save_string = ndr->flags;
13403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_name));
13405                         if (_ptr_inf_name) {
13406                                 NDR_PULL_ALLOC(ndr, r->inf_name);
13407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_name, _ptr_inf_name));
13408                         } else {
13409                                 r->inf_name = NULL;
13410                         }
13411                         ndr->flags = _flags_save_string;
13412                 }
13413                 {
13414                         uint32_t _flags_save_string = ndr->flags;
13415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13416                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_install_source_root));
13417                         if (_ptr_install_source_root) {
13418                                 NDR_PULL_ALLOC(ndr, r->install_source_root);
13419                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->install_source_root, _ptr_install_source_root));
13420                         } else {
13421                                 r->install_source_root = NULL;
13422                         }
13423                         ndr->flags = _flags_save_string;
13424                 }
13425                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13426         }
13427         if (ndr_flags & NDR_BUFFERS) {
13428                 {
13429                         uint32_t _flags_save_string = ndr->flags;
13430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13431                         if (r->driver_name) {
13432                                 uint32_t _relative_save_offset;
13433                                 _relative_save_offset = ndr->offset;
13434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13435                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13436                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13439                                 ndr->offset = _relative_save_offset;
13440                         }
13441                         ndr->flags = _flags_save_string;
13442                 }
13443                 {
13444                         uint32_t _flags_save_string = ndr->flags;
13445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13446                         if (r->inf_name) {
13447                                 uint32_t _relative_save_offset;
13448                                 _relative_save_offset = ndr->offset;
13449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_name));
13450                                 _mem_save_inf_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13451                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_name, 0);
13452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_name));
13453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_name_0, 0);
13454                                 ndr->offset = _relative_save_offset;
13455                         }
13456                         ndr->flags = _flags_save_string;
13457                 }
13458                 {
13459                         uint32_t _flags_save_string = ndr->flags;
13460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13461                         if (r->install_source_root) {
13462                                 uint32_t _relative_save_offset;
13463                                 _relative_save_offset = ndr->offset;
13464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->install_source_root));
13465                                 _mem_save_install_source_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
13466                                 NDR_PULL_SET_MEM_CTX(ndr, r->install_source_root, 0);
13467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->install_source_root));
13468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_install_source_root_0, 0);
13469                                 ndr->offset = _relative_save_offset;
13470                         }
13471                         ndr->flags = _flags_save_string;
13472                 }
13473         }
13474         return NDR_ERR_SUCCESS;
13475 }
13476
13477 _PUBLIC_ void ndr_print_spoolss_DriverInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo7 *r)
13478 {
13479         ndr_print_struct(ndr, name, "spoolss_DriverInfo7");
13480         ndr->depth++;
13481         ndr_print_uint32(ndr, "size", r->size);
13482         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13483         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13484         ndr->depth++;
13485         if (r->driver_name) {
13486                 ndr_print_string(ndr, "driver_name", r->driver_name);
13487         }
13488         ndr->depth--;
13489         ndr_print_ptr(ndr, "inf_name", r->inf_name);
13490         ndr->depth++;
13491         if (r->inf_name) {
13492                 ndr_print_string(ndr, "inf_name", r->inf_name);
13493         }
13494         ndr->depth--;
13495         ndr_print_ptr(ndr, "install_source_root", r->install_source_root);
13496         ndr->depth++;
13497         if (r->install_source_root) {
13498                 ndr_print_string(ndr, "install_source_root", r->install_source_root);
13499         }
13500         ndr->depth--;
13501         ndr->depth--;
13502 }
13503
13504 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo7(const struct spoolss_DriverInfo7 *r, struct smb_iconv_convenience *ic, int flags)
13505 {
13506         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo7, ic);
13507 }
13508
13509 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13510 {
13511         if (ndr_flags & NDR_SCALARS) {
13512                 NDR_CHECK(ndr_push_align(ndr, 8));
13513                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13514                 {
13515                         uint32_t _flags_save_string = ndr->flags;
13516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13517                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13518                         ndr->flags = _flags_save_string;
13519                 }
13520                 {
13521                         uint32_t _flags_save_string = ndr->flags;
13522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13523                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13524                         ndr->flags = _flags_save_string;
13525                 }
13526                 {
13527                         uint32_t _flags_save_string = ndr->flags;
13528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13530                         ndr->flags = _flags_save_string;
13531                 }
13532                 {
13533                         uint32_t _flags_save_string = ndr->flags;
13534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13536                         ndr->flags = _flags_save_string;
13537                 }
13538                 {
13539                         uint32_t _flags_save_string = ndr->flags;
13540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13541                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13542                         ndr->flags = _flags_save_string;
13543                 }
13544                 {
13545                         uint32_t _flags_save_string = ndr->flags;
13546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13547                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13548                         ndr->flags = _flags_save_string;
13549                 }
13550                 {
13551                         uint32_t _flags_save_string_array = ndr->flags;
13552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13553                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13554                         ndr->flags = _flags_save_string_array;
13555                 }
13556                 {
13557                         uint32_t _flags_save_string = ndr->flags;
13558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13559                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13560                         ndr->flags = _flags_save_string;
13561                 }
13562                 {
13563                         uint32_t _flags_save_string = ndr->flags;
13564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13566                         ndr->flags = _flags_save_string;
13567                 }
13568                 {
13569                         uint32_t _flags_save_string_array = ndr->flags;
13570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13572                         ndr->flags = _flags_save_string_array;
13573                 }
13574                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13575                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13576                 {
13577                         uint32_t _flags_save_string = ndr->flags;
13578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13580                         ndr->flags = _flags_save_string;
13581                 }
13582                 {
13583                         uint32_t _flags_save_string = ndr->flags;
13584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13586                         ndr->flags = _flags_save_string;
13587                 }
13588                 {
13589                         uint32_t _flags_save_string = ndr->flags;
13590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13591                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13592                         ndr->flags = _flags_save_string;
13593                 }
13594                 {
13595                         uint32_t _flags_save_string = ndr->flags;
13596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13597                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13598                         ndr->flags = _flags_save_string;
13599                 }
13600                 {
13601                         uint32_t _flags_save_string = ndr->flags;
13602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13603                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13604                         ndr->flags = _flags_save_string;
13605                 }
13606                 {
13607                         uint32_t _flags_save_string = ndr->flags;
13608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13610                         ndr->flags = _flags_save_string;
13611                 }
13612                 {
13613                         uint32_t _flags_save_string_array = ndr->flags;
13614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13615                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13616                         ndr->flags = _flags_save_string_array;
13617                 }
13618                 {
13619                         uint32_t _flags_save_string = ndr->flags;
13620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13621                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13622                         ndr->flags = _flags_save_string;
13623                 }
13624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13625                 {
13626                         uint32_t _flags_save_string_array = ndr->flags;
13627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13628                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13629                         ndr->flags = _flags_save_string_array;
13630                 }
13631                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13632                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13633                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13634         }
13635         if (ndr_flags & NDR_BUFFERS) {
13636                 {
13637                         uint32_t _flags_save_string = ndr->flags;
13638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13639                         if (r->driver_name) {
13640                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13641                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13642                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13643                         }
13644                         ndr->flags = _flags_save_string;
13645                 }
13646                 {
13647                         uint32_t _flags_save_string = ndr->flags;
13648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13649                         if (r->architecture) {
13650                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
13651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13652                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
13653                         }
13654                         ndr->flags = _flags_save_string;
13655                 }
13656                 {
13657                         uint32_t _flags_save_string = ndr->flags;
13658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13659                         if (r->driver_path) {
13660                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
13661                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13662                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
13663                         }
13664                         ndr->flags = _flags_save_string;
13665                 }
13666                 {
13667                         uint32_t _flags_save_string = ndr->flags;
13668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13669                         if (r->data_file) {
13670                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
13671                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13672                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
13673                         }
13674                         ndr->flags = _flags_save_string;
13675                 }
13676                 {
13677                         uint32_t _flags_save_string = ndr->flags;
13678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13679                         if (r->config_file) {
13680                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
13681                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13682                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
13683                         }
13684                         ndr->flags = _flags_save_string;
13685                 }
13686                 {
13687                         uint32_t _flags_save_string = ndr->flags;
13688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13689                         if (r->help_file) {
13690                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
13691                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13692                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
13693                         }
13694                         ndr->flags = _flags_save_string;
13695                 }
13696                 {
13697                         uint32_t _flags_save_string_array = ndr->flags;
13698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13699                         if (r->dependent_files) {
13700                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
13701                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13702                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
13703                         }
13704                         ndr->flags = _flags_save_string_array;
13705                 }
13706                 {
13707                         uint32_t _flags_save_string = ndr->flags;
13708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13709                         if (r->monitor_name) {
13710                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
13711                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13712                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
13713                         }
13714                         ndr->flags = _flags_save_string;
13715                 }
13716                 {
13717                         uint32_t _flags_save_string = ndr->flags;
13718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13719                         if (r->default_datatype) {
13720                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
13721                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13722                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
13723                         }
13724                         ndr->flags = _flags_save_string;
13725                 }
13726                 {
13727                         uint32_t _flags_save_string_array = ndr->flags;
13728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13729                         if (r->previous_names) {
13730                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
13731                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13732                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
13733                         }
13734                         ndr->flags = _flags_save_string_array;
13735                 }
13736                 {
13737                         uint32_t _flags_save_string = ndr->flags;
13738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13739                         if (r->manufacturer_name) {
13740                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
13741                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13742                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
13743                         }
13744                         ndr->flags = _flags_save_string;
13745                 }
13746                 {
13747                         uint32_t _flags_save_string = ndr->flags;
13748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13749                         if (r->manufacturer_url) {
13750                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
13751                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13752                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
13753                         }
13754                         ndr->flags = _flags_save_string;
13755                 }
13756                 {
13757                         uint32_t _flags_save_string = ndr->flags;
13758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13759                         if (r->hardware_id) {
13760                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
13761                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13762                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
13763                         }
13764                         ndr->flags = _flags_save_string;
13765                 }
13766                 {
13767                         uint32_t _flags_save_string = ndr->flags;
13768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13769                         if (r->provider) {
13770                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
13771                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13772                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
13773                         }
13774                         ndr->flags = _flags_save_string;
13775                 }
13776                 {
13777                         uint32_t _flags_save_string = ndr->flags;
13778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13779                         if (r->print_processor) {
13780                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
13781                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13782                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
13783                         }
13784                         ndr->flags = _flags_save_string;
13785                 }
13786                 {
13787                         uint32_t _flags_save_string = ndr->flags;
13788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13789                         if (r->vendor_setup) {
13790                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->vendor_setup));
13791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13792                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->vendor_setup));
13793                         }
13794                         ndr->flags = _flags_save_string;
13795                 }
13796                 {
13797                         uint32_t _flags_save_string_array = ndr->flags;
13798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13799                         if (r->color_profiles) {
13800                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->color_profiles));
13801                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13802                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->color_profiles));
13803                         }
13804                         ndr->flags = _flags_save_string_array;
13805                 }
13806                 {
13807                         uint32_t _flags_save_string = ndr->flags;
13808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13809                         if (r->inf_path) {
13810                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_path));
13811                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13812                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_path));
13813                         }
13814                         ndr->flags = _flags_save_string;
13815                 }
13816                 {
13817                         uint32_t _flags_save_string_array = ndr->flags;
13818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13819                         if (r->core_driver_dependencies) {
13820                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->core_driver_dependencies));
13821                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13822                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->core_driver_dependencies));
13823                         }
13824                         ndr->flags = _flags_save_string_array;
13825                 }
13826         }
13827         return NDR_ERR_SUCCESS;
13828 }
13829
13830 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13831 {
13832         uint32_t _ptr_driver_name;
13833         TALLOC_CTX *_mem_save_driver_name_0;
13834         uint32_t _ptr_architecture;
13835         TALLOC_CTX *_mem_save_architecture_0;
13836         uint32_t _ptr_driver_path;
13837         TALLOC_CTX *_mem_save_driver_path_0;
13838         uint32_t _ptr_data_file;
13839         TALLOC_CTX *_mem_save_data_file_0;
13840         uint32_t _ptr_config_file;
13841         TALLOC_CTX *_mem_save_config_file_0;
13842         uint32_t _ptr_help_file;
13843         TALLOC_CTX *_mem_save_help_file_0;
13844         uint32_t _ptr_dependent_files;
13845         TALLOC_CTX *_mem_save_dependent_files_0;
13846         uint32_t _ptr_monitor_name;
13847         TALLOC_CTX *_mem_save_monitor_name_0;
13848         uint32_t _ptr_default_datatype;
13849         TALLOC_CTX *_mem_save_default_datatype_0;
13850         uint32_t _ptr_previous_names;
13851         TALLOC_CTX *_mem_save_previous_names_0;
13852         uint32_t _ptr_manufacturer_name;
13853         TALLOC_CTX *_mem_save_manufacturer_name_0;
13854         uint32_t _ptr_manufacturer_url;
13855         TALLOC_CTX *_mem_save_manufacturer_url_0;
13856         uint32_t _ptr_hardware_id;
13857         TALLOC_CTX *_mem_save_hardware_id_0;
13858         uint32_t _ptr_provider;
13859         TALLOC_CTX *_mem_save_provider_0;
13860         uint32_t _ptr_print_processor;
13861         TALLOC_CTX *_mem_save_print_processor_0;
13862         uint32_t _ptr_vendor_setup;
13863         TALLOC_CTX *_mem_save_vendor_setup_0;
13864         uint32_t _ptr_color_profiles;
13865         TALLOC_CTX *_mem_save_color_profiles_0;
13866         uint32_t _ptr_inf_path;
13867         TALLOC_CTX *_mem_save_inf_path_0;
13868         uint32_t _ptr_core_driver_dependencies;
13869         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13870         if (ndr_flags & NDR_SCALARS) {
13871                 NDR_CHECK(ndr_pull_align(ndr, 8));
13872                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13873                 {
13874                         uint32_t _flags_save_string = ndr->flags;
13875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13876                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13877                         if (_ptr_driver_name) {
13878                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13879                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13880                         } else {
13881                                 r->driver_name = NULL;
13882                         }
13883                         ndr->flags = _flags_save_string;
13884                 }
13885                 {
13886                         uint32_t _flags_save_string = ndr->flags;
13887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13888                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13889                         if (_ptr_architecture) {
13890                                 NDR_PULL_ALLOC(ndr, r->architecture);
13891                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13892                         } else {
13893                                 r->architecture = NULL;
13894                         }
13895                         ndr->flags = _flags_save_string;
13896                 }
13897                 {
13898                         uint32_t _flags_save_string = ndr->flags;
13899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13900                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13901                         if (_ptr_driver_path) {
13902                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13903                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13904                         } else {
13905                                 r->driver_path = NULL;
13906                         }
13907                         ndr->flags = _flags_save_string;
13908                 }
13909                 {
13910                         uint32_t _flags_save_string = ndr->flags;
13911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13912                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13913                         if (_ptr_data_file) {
13914                                 NDR_PULL_ALLOC(ndr, r->data_file);
13915                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13916                         } else {
13917                                 r->data_file = NULL;
13918                         }
13919                         ndr->flags = _flags_save_string;
13920                 }
13921                 {
13922                         uint32_t _flags_save_string = ndr->flags;
13923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13924                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13925                         if (_ptr_config_file) {
13926                                 NDR_PULL_ALLOC(ndr, r->config_file);
13927                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13928                         } else {
13929                                 r->config_file = NULL;
13930                         }
13931                         ndr->flags = _flags_save_string;
13932                 }
13933                 {
13934                         uint32_t _flags_save_string = ndr->flags;
13935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13936                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13937                         if (_ptr_help_file) {
13938                                 NDR_PULL_ALLOC(ndr, r->help_file);
13939                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13940                         } else {
13941                                 r->help_file = NULL;
13942                         }
13943                         ndr->flags = _flags_save_string;
13944                 }
13945                 {
13946                         uint32_t _flags_save_string_array = ndr->flags;
13947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13948                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13949                         if (_ptr_dependent_files) {
13950                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13951                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13952                         } else {
13953                                 r->dependent_files = NULL;
13954                         }
13955                         ndr->flags = _flags_save_string_array;
13956                 }
13957                 {
13958                         uint32_t _flags_save_string = ndr->flags;
13959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13960                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13961                         if (_ptr_monitor_name) {
13962                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13963                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13964                         } else {
13965                                 r->monitor_name = NULL;
13966                         }
13967                         ndr->flags = _flags_save_string;
13968                 }
13969                 {
13970                         uint32_t _flags_save_string = ndr->flags;
13971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13972                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13973                         if (_ptr_default_datatype) {
13974                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13975                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13976                         } else {
13977                                 r->default_datatype = NULL;
13978                         }
13979                         ndr->flags = _flags_save_string;
13980                 }
13981                 {
13982                         uint32_t _flags_save_string_array = ndr->flags;
13983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13984                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13985                         if (_ptr_previous_names) {
13986                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13987                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13988                         } else {
13989                                 r->previous_names = NULL;
13990                         }
13991                         ndr->flags = _flags_save_string_array;
13992                 }
13993                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13994                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13995                 {
13996                         uint32_t _flags_save_string = ndr->flags;
13997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13998                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13999                         if (_ptr_manufacturer_name) {
14000                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
14001                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
14002                         } else {
14003                                 r->manufacturer_name = NULL;
14004                         }
14005                         ndr->flags = _flags_save_string;
14006                 }
14007                 {
14008                         uint32_t _flags_save_string = ndr->flags;
14009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14010                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
14011                         if (_ptr_manufacturer_url) {
14012                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
14013                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
14014                         } else {
14015                                 r->manufacturer_url = NULL;
14016                         }
14017                         ndr->flags = _flags_save_string;
14018                 }
14019                 {
14020                         uint32_t _flags_save_string = ndr->flags;
14021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14022                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
14023                         if (_ptr_hardware_id) {
14024                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
14025                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
14026                         } else {
14027                                 r->hardware_id = NULL;
14028                         }
14029                         ndr->flags = _flags_save_string;
14030                 }
14031                 {
14032                         uint32_t _flags_save_string = ndr->flags;
14033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14034                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
14035                         if (_ptr_provider) {
14036                                 NDR_PULL_ALLOC(ndr, r->provider);
14037                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
14038                         } else {
14039                                 r->provider = NULL;
14040                         }
14041                         ndr->flags = _flags_save_string;
14042                 }
14043                 {
14044                         uint32_t _flags_save_string = ndr->flags;
14045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14046                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
14047                         if (_ptr_print_processor) {
14048                                 NDR_PULL_ALLOC(ndr, r->print_processor);
14049                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
14050                         } else {
14051                                 r->print_processor = NULL;
14052                         }
14053                         ndr->flags = _flags_save_string;
14054                 }
14055                 {
14056                         uint32_t _flags_save_string = ndr->flags;
14057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14058                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
14059                         if (_ptr_vendor_setup) {
14060                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
14061                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
14062                         } else {
14063                                 r->vendor_setup = NULL;
14064                         }
14065                         ndr->flags = _flags_save_string;
14066                 }
14067                 {
14068                         uint32_t _flags_save_string_array = ndr->flags;
14069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14070                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
14071                         if (_ptr_color_profiles) {
14072                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
14073                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
14074                         } else {
14075                                 r->color_profiles = NULL;
14076                         }
14077                         ndr->flags = _flags_save_string_array;
14078                 }
14079                 {
14080                         uint32_t _flags_save_string = ndr->flags;
14081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14082                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
14083                         if (_ptr_inf_path) {
14084                                 NDR_PULL_ALLOC(ndr, r->inf_path);
14085                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
14086                         } else {
14087                                 r->inf_path = NULL;
14088                         }
14089                         ndr->flags = _flags_save_string;
14090                 }
14091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
14092                 {
14093                         uint32_t _flags_save_string_array = ndr->flags;
14094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14095                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
14096                         if (_ptr_core_driver_dependencies) {
14097                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
14098                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
14099                         } else {
14100                                 r->core_driver_dependencies = NULL;
14101                         }
14102                         ndr->flags = _flags_save_string_array;
14103                 }
14104                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
14105                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
14106                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
14107         }
14108         if (ndr_flags & NDR_BUFFERS) {
14109                 {
14110                         uint32_t _flags_save_string = ndr->flags;
14111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14112                         if (r->driver_name) {
14113                                 uint32_t _relative_save_offset;
14114                                 _relative_save_offset = ndr->offset;
14115                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
14116                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14117                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
14118                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
14119                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
14120                                 ndr->offset = _relative_save_offset;
14121                         }
14122                         ndr->flags = _flags_save_string;
14123                 }
14124                 {
14125                         uint32_t _flags_save_string = ndr->flags;
14126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14127                         if (r->architecture) {
14128                                 uint32_t _relative_save_offset;
14129                                 _relative_save_offset = ndr->offset;
14130                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
14131                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
14132                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
14133                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
14134                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
14135                                 ndr->offset = _relative_save_offset;
14136                         }
14137                         ndr->flags = _flags_save_string;
14138                 }
14139                 {
14140                         uint32_t _flags_save_string = ndr->flags;
14141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14142                         if (r->driver_path) {
14143                                 uint32_t _relative_save_offset;
14144                                 _relative_save_offset = ndr->offset;
14145                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
14146                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14147                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
14148                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
14149                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
14150                                 ndr->offset = _relative_save_offset;
14151                         }
14152                         ndr->flags = _flags_save_string;
14153                 }
14154                 {
14155                         uint32_t _flags_save_string = ndr->flags;
14156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14157                         if (r->data_file) {
14158                                 uint32_t _relative_save_offset;
14159                                 _relative_save_offset = ndr->offset;
14160                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
14161                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14162                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
14163                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
14164                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
14165                                 ndr->offset = _relative_save_offset;
14166                         }
14167                         ndr->flags = _flags_save_string;
14168                 }
14169                 {
14170                         uint32_t _flags_save_string = ndr->flags;
14171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14172                         if (r->config_file) {
14173                                 uint32_t _relative_save_offset;
14174                                 _relative_save_offset = ndr->offset;
14175                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
14176                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14177                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
14178                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
14179                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
14180                                 ndr->offset = _relative_save_offset;
14181                         }
14182                         ndr->flags = _flags_save_string;
14183                 }
14184                 {
14185                         uint32_t _flags_save_string = ndr->flags;
14186                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14187                         if (r->help_file) {
14188                                 uint32_t _relative_save_offset;
14189                                 _relative_save_offset = ndr->offset;
14190                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
14191                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14192                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
14193                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
14194                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
14195                                 ndr->offset = _relative_save_offset;
14196                         }
14197                         ndr->flags = _flags_save_string;
14198                 }
14199                 {
14200                         uint32_t _flags_save_string_array = ndr->flags;
14201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14202                         if (r->dependent_files) {
14203                                 uint32_t _relative_save_offset;
14204                                 _relative_save_offset = ndr->offset;
14205                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
14206                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
14207                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
14208                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
14209                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
14210                                 ndr->offset = _relative_save_offset;
14211                         }
14212                         ndr->flags = _flags_save_string_array;
14213                 }
14214                 {
14215                         uint32_t _flags_save_string = ndr->flags;
14216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14217                         if (r->monitor_name) {
14218                                 uint32_t _relative_save_offset;
14219                                 _relative_save_offset = ndr->offset;
14220                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14221                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14222                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14223                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14224                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14225                                 ndr->offset = _relative_save_offset;
14226                         }
14227                         ndr->flags = _flags_save_string;
14228                 }
14229                 {
14230                         uint32_t _flags_save_string = ndr->flags;
14231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14232                         if (r->default_datatype) {
14233                                 uint32_t _relative_save_offset;
14234                                 _relative_save_offset = ndr->offset;
14235                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
14236                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14237                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
14238                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
14239                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
14240                                 ndr->offset = _relative_save_offset;
14241                         }
14242                         ndr->flags = _flags_save_string;
14243                 }
14244                 {
14245                         uint32_t _flags_save_string_array = ndr->flags;
14246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14247                         if (r->previous_names) {
14248                                 uint32_t _relative_save_offset;
14249                                 _relative_save_offset = ndr->offset;
14250                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
14251                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
14252                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
14253                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
14254                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
14255                                 ndr->offset = _relative_save_offset;
14256                         }
14257                         ndr->flags = _flags_save_string_array;
14258                 }
14259                 {
14260                         uint32_t _flags_save_string = ndr->flags;
14261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14262                         if (r->manufacturer_name) {
14263                                 uint32_t _relative_save_offset;
14264                                 _relative_save_offset = ndr->offset;
14265                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
14266                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14267                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
14268                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
14269                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
14270                                 ndr->offset = _relative_save_offset;
14271                         }
14272                         ndr->flags = _flags_save_string;
14273                 }
14274                 {
14275                         uint32_t _flags_save_string = ndr->flags;
14276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14277                         if (r->manufacturer_url) {
14278                                 uint32_t _relative_save_offset;
14279                                 _relative_save_offset = ndr->offset;
14280                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
14281                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
14282                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
14283                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
14284                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
14285                                 ndr->offset = _relative_save_offset;
14286                         }
14287                         ndr->flags = _flags_save_string;
14288                 }
14289                 {
14290                         uint32_t _flags_save_string = ndr->flags;
14291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14292                         if (r->hardware_id) {
14293                                 uint32_t _relative_save_offset;
14294                                 _relative_save_offset = ndr->offset;
14295                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
14296                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
14297                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
14298                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
14299                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
14300                                 ndr->offset = _relative_save_offset;
14301                         }
14302                         ndr->flags = _flags_save_string;
14303                 }
14304                 {
14305                         uint32_t _flags_save_string = ndr->flags;
14306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14307                         if (r->provider) {
14308                                 uint32_t _relative_save_offset;
14309                                 _relative_save_offset = ndr->offset;
14310                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
14311                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
14312                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
14313                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
14314                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
14315                                 ndr->offset = _relative_save_offset;
14316                         }
14317                         ndr->flags = _flags_save_string;
14318                 }
14319                 {
14320                         uint32_t _flags_save_string = ndr->flags;
14321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14322                         if (r->print_processor) {
14323                                 uint32_t _relative_save_offset;
14324                                 _relative_save_offset = ndr->offset;
14325                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
14326                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
14327                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
14328                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
14329                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
14330                                 ndr->offset = _relative_save_offset;
14331                         }
14332                         ndr->flags = _flags_save_string;
14333                 }
14334                 {
14335                         uint32_t _flags_save_string = ndr->flags;
14336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14337                         if (r->vendor_setup) {
14338                                 uint32_t _relative_save_offset;
14339                                 _relative_save_offset = ndr->offset;
14340                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14341                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14342                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14343                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14344                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14345                                 ndr->offset = _relative_save_offset;
14346                         }
14347                         ndr->flags = _flags_save_string;
14348                 }
14349                 {
14350                         uint32_t _flags_save_string_array = ndr->flags;
14351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14352                         if (r->color_profiles) {
14353                                 uint32_t _relative_save_offset;
14354                                 _relative_save_offset = ndr->offset;
14355                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14356                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14357                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14358                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14359                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14360                                 ndr->offset = _relative_save_offset;
14361                         }
14362                         ndr->flags = _flags_save_string_array;
14363                 }
14364                 {
14365                         uint32_t _flags_save_string = ndr->flags;
14366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14367                         if (r->inf_path) {
14368                                 uint32_t _relative_save_offset;
14369                                 _relative_save_offset = ndr->offset;
14370                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14371                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14372                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14373                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14374                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14375                                 ndr->offset = _relative_save_offset;
14376                         }
14377                         ndr->flags = _flags_save_string;
14378                 }
14379                 {
14380                         uint32_t _flags_save_string_array = ndr->flags;
14381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14382                         if (r->core_driver_dependencies) {
14383                                 uint32_t _relative_save_offset;
14384                                 _relative_save_offset = ndr->offset;
14385                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14386                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14387                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14388                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14389                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14390                                 ndr->offset = _relative_save_offset;
14391                         }
14392                         ndr->flags = _flags_save_string_array;
14393                 }
14394         }
14395         return NDR_ERR_SUCCESS;
14396 }
14397
14398 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14399 {
14400         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14401         ndr->depth++;
14402         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14403         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14404         ndr->depth++;
14405         if (r->driver_name) {
14406                 ndr_print_string(ndr, "driver_name", r->driver_name);
14407         }
14408         ndr->depth--;
14409         ndr_print_ptr(ndr, "architecture", r->architecture);
14410         ndr->depth++;
14411         if (r->architecture) {
14412                 ndr_print_string(ndr, "architecture", r->architecture);
14413         }
14414         ndr->depth--;
14415         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14416         ndr->depth++;
14417         if (r->driver_path) {
14418                 ndr_print_string(ndr, "driver_path", r->driver_path);
14419         }
14420         ndr->depth--;
14421         ndr_print_ptr(ndr, "data_file", r->data_file);
14422         ndr->depth++;
14423         if (r->data_file) {
14424                 ndr_print_string(ndr, "data_file", r->data_file);
14425         }
14426         ndr->depth--;
14427         ndr_print_ptr(ndr, "config_file", r->config_file);
14428         ndr->depth++;
14429         if (r->config_file) {
14430                 ndr_print_string(ndr, "config_file", r->config_file);
14431         }
14432         ndr->depth--;
14433         ndr_print_ptr(ndr, "help_file", r->help_file);
14434         ndr->depth++;
14435         if (r->help_file) {
14436                 ndr_print_string(ndr, "help_file", r->help_file);
14437         }
14438         ndr->depth--;
14439         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14440         ndr->depth++;
14441         if (r->dependent_files) {
14442                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14443         }
14444         ndr->depth--;
14445         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14446         ndr->depth++;
14447         if (r->monitor_name) {
14448                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14449         }
14450         ndr->depth--;
14451         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14452         ndr->depth++;
14453         if (r->default_datatype) {
14454                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14455         }
14456         ndr->depth--;
14457         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14458         ndr->depth++;
14459         if (r->previous_names) {
14460                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14461         }
14462         ndr->depth--;
14463         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14464         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14465         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14466         ndr->depth++;
14467         if (r->manufacturer_name) {
14468                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14469         }
14470         ndr->depth--;
14471         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14472         ndr->depth++;
14473         if (r->manufacturer_url) {
14474                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14475         }
14476         ndr->depth--;
14477         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14478         ndr->depth++;
14479         if (r->hardware_id) {
14480                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14481         }
14482         ndr->depth--;
14483         ndr_print_ptr(ndr, "provider", r->provider);
14484         ndr->depth++;
14485         if (r->provider) {
14486                 ndr_print_string(ndr, "provider", r->provider);
14487         }
14488         ndr->depth--;
14489         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14490         ndr->depth++;
14491         if (r->print_processor) {
14492                 ndr_print_string(ndr, "print_processor", r->print_processor);
14493         }
14494         ndr->depth--;
14495         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14496         ndr->depth++;
14497         if (r->vendor_setup) {
14498                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14499         }
14500         ndr->depth--;
14501         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14502         ndr->depth++;
14503         if (r->color_profiles) {
14504                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14505         }
14506         ndr->depth--;
14507         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14508         ndr->depth++;
14509         if (r->inf_path) {
14510                 ndr_print_string(ndr, "inf_path", r->inf_path);
14511         }
14512         ndr->depth--;
14513         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14514         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14515         ndr->depth++;
14516         if (r->core_driver_dependencies) {
14517                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14518         }
14519         ndr->depth--;
14520         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14521         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14522         ndr->depth--;
14523 }
14524
14525 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14526 {
14527         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14528 }
14529
14530 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14531 {
14532         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14533         return NDR_ERR_SUCCESS;
14534 }
14535
14536 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14537 {
14538         uint32_t v;
14539         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14540         *r = v;
14541         return NDR_ERR_SUCCESS;
14542 }
14543
14544 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14545 {
14546         const char *val = NULL;
14547
14548         switch (r) {
14549                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14550                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14551                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14552                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14553                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14554         }
14555         ndr_print_enum(ndr, name, "ENUM", val, r);
14556 }
14557
14558 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14559 {
14560         if (ndr_flags & NDR_SCALARS) {
14561                 NDR_CHECK(ndr_push_align(ndr, 5));
14562                 {
14563                         uint32_t _flags_save_string = ndr->flags;
14564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14566                         ndr->flags = _flags_save_string;
14567                 }
14568                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14570                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14571         }
14572         if (ndr_flags & NDR_BUFFERS) {
14573                 {
14574                         uint32_t _flags_save_string = ndr->flags;
14575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14576                         if (r->file_name) {
14577                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_name));
14578                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14579                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_name));
14580                         }
14581                         ndr->flags = _flags_save_string;
14582                 }
14583         }
14584         return NDR_ERR_SUCCESS;
14585 }
14586
14587 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14588 {
14589         uint32_t _ptr_file_name;
14590         TALLOC_CTX *_mem_save_file_name_0;
14591         if (ndr_flags & NDR_SCALARS) {
14592                 NDR_CHECK(ndr_pull_align(ndr, 5));
14593                 {
14594                         uint32_t _flags_save_string = ndr->flags;
14595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14596                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14597                         if (_ptr_file_name) {
14598                                 NDR_PULL_ALLOC(ndr, r->file_name);
14599                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14600                         } else {
14601                                 r->file_name = NULL;
14602                         }
14603                         ndr->flags = _flags_save_string;
14604                 }
14605                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14607                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14608         }
14609         if (ndr_flags & NDR_BUFFERS) {
14610                 {
14611                         uint32_t _flags_save_string = ndr->flags;
14612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14613                         if (r->file_name) {
14614                                 uint32_t _relative_save_offset;
14615                                 _relative_save_offset = ndr->offset;
14616                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14617                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14618                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14619                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14620                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14621                                 ndr->offset = _relative_save_offset;
14622                         }
14623                         ndr->flags = _flags_save_string;
14624                 }
14625         }
14626         return NDR_ERR_SUCCESS;
14627 }
14628
14629 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14630 {
14631         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14632         ndr->depth++;
14633         ndr_print_ptr(ndr, "file_name", r->file_name);
14634         ndr->depth++;
14635         if (r->file_name) {
14636                 ndr_print_string(ndr, "file_name", r->file_name);
14637         }
14638         ndr->depth--;
14639         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14640         ndr_print_uint32(ndr, "file_version", r->file_version);
14641         ndr->depth--;
14642 }
14643
14644 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14645 {
14646         uint32_t cntr_file_info_1;
14647         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14648         ndr->depth++;
14649         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14650         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14651         ndr->depth++;
14652         if (r->driver_name) {
14653                 ndr_print_string(ndr, "driver_name", r->driver_name);
14654         }
14655         ndr->depth--;
14656         ndr_print_ptr(ndr, "architecture", r->architecture);
14657         ndr->depth++;
14658         if (r->architecture) {
14659                 ndr_print_string(ndr, "architecture", r->architecture);
14660         }
14661         ndr->depth--;
14662         ndr_print_ptr(ndr, "file_info", r->file_info);
14663         ndr->depth++;
14664         if (r->file_info) {
14665                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14666                 ndr->depth++;
14667                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14668                         char *idx_1=NULL;
14669                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14670                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14671                                 free(idx_1);
14672                         }
14673                 }
14674                 ndr->depth--;
14675         }
14676         ndr->depth--;
14677         ndr_print_uint32(ndr, "file_count", r->file_count);
14678         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14679         ndr->depth++;
14680         if (r->monitor_name) {
14681                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14682         }
14683         ndr->depth--;
14684         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14685         ndr->depth++;
14686         if (r->default_datatype) {
14687                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14688         }
14689         ndr->depth--;
14690         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14691         ndr->depth++;
14692         if (r->previous_names) {
14693                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14694         }
14695         ndr->depth--;
14696         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14697         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14698         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14699         ndr->depth++;
14700         if (r->manufacturer_name) {
14701                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14702         }
14703         ndr->depth--;
14704         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14705         ndr->depth++;
14706         if (r->manufacturer_url) {
14707                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14708         }
14709         ndr->depth--;
14710         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14711         ndr->depth++;
14712         if (r->hardware_id) {
14713                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14714         }
14715         ndr->depth--;
14716         ndr_print_ptr(ndr, "provider", r->provider);
14717         ndr->depth++;
14718         if (r->provider) {
14719                 ndr_print_string(ndr, "provider", r->provider);
14720         }
14721         ndr->depth--;
14722         ndr->depth--;
14723 }
14724
14725 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14726 {
14727         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14728 }
14729
14730 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14731 {
14732         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14733         {
14734                 uint32_t _flags_save_UNION = ndr->flags;
14735                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14736                 if (ndr_flags & NDR_SCALARS) {
14737                         int level = ndr_push_get_switch_value(ndr, r);
14738                         NDR_CHECK(ndr_push_union_align(ndr, 8));
14739                         switch (level) {
14740                                 case 1: {
14741                                         NDR_CHECK(ndr_push_align(ndr, 5));
14742                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14743                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14744                                 break; }
14745
14746                                 case 2: {
14747                                         NDR_CHECK(ndr_push_align(ndr, 5));
14748                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14749                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14750                                 break; }
14751
14752                                 case 3: {
14753                                         NDR_CHECK(ndr_push_align(ndr, 5));
14754                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14755                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14756                                 break; }
14757
14758                                 case 4: {
14759                                         NDR_CHECK(ndr_push_align(ndr, 5));
14760                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14761                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14762                                 break; }
14763
14764                                 case 5: {
14765                                         NDR_CHECK(ndr_push_align(ndr, 5));
14766                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14767                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14768                                 break; }
14769
14770                                 case 6: {
14771                                         NDR_CHECK(ndr_push_align(ndr, 8));
14772                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14773                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14774                                 break; }
14775
14776                                 case 7: {
14777                                         NDR_CHECK(ndr_push_align(ndr, 5));
14778                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14779                                         NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14780                                 break; }
14781
14782                                 case 8: {
14783                                         NDR_CHECK(ndr_push_align(ndr, 8));
14784                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14785                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14786                                 break; }
14787
14788                                 case 101: {
14789                                         NDR_CHECK(ndr_push_align(ndr, 8));
14790                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14791                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14792                                 break; }
14793
14794                                 default: {
14795                                 break; }
14796
14797                         }
14798                 }
14799                 if (ndr_flags & NDR_BUFFERS) {
14800                         int level = ndr_push_get_switch_value(ndr, r);
14801                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14802                         switch (level) {
14803                                 case 1:
14804                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14805                                 break;
14806
14807                                 case 2:
14808                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14809                                 break;
14810
14811                                 case 3:
14812                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14813                                 break;
14814
14815                                 case 4:
14816                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14817                                 break;
14818
14819                                 case 5:
14820                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14821                                 break;
14822
14823                                 case 6:
14824                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14825                                 break;
14826
14827                                 case 7:
14828                                         NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14829                                 break;
14830
14831                                 case 8:
14832                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14833                                 break;
14834
14835                                 case 101:
14836                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14837                                 break;
14838
14839                                 default:
14840                                 break;
14841
14842                         }
14843                 }
14844                 ndr->flags = _flags_save_UNION;
14845         }
14846         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14847         return NDR_ERR_SUCCESS;
14848 }
14849
14850 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14851 {
14852         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14853         int level;
14854         {
14855                 uint32_t _flags_save_UNION = ndr->flags;
14856                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14857                 level = ndr_pull_get_switch_value(ndr, r);
14858                 if (ndr_flags & NDR_SCALARS) {
14859                         NDR_CHECK(ndr_pull_union_align(ndr, 8));
14860                         switch (level) {
14861                                 case 1: {
14862                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14863                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14864                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14865                                 break; }
14866
14867                                 case 2: {
14868                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14869                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14870                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14871                                 break; }
14872
14873                                 case 3: {
14874                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14875                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14876                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14877                                 break; }
14878
14879                                 case 4: {
14880                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14881                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14882                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14883                                 break; }
14884
14885                                 case 5: {
14886                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14887                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14888                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14889                                 break; }
14890
14891                                 case 6: {
14892                                         NDR_CHECK(ndr_pull_align(ndr, 8));
14893                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14894                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14895                                 break; }
14896
14897                                 case 7: {
14898                                         NDR_CHECK(ndr_pull_align(ndr, 5));
14899                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14900                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14901                                 break; }
14902
14903                                 case 8: {
14904                                         NDR_CHECK(ndr_pull_align(ndr, 8));
14905                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14906                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14907                                 break; }
14908
14909                                 case 101: {
14910                                         NDR_CHECK(ndr_pull_align(ndr, 8));
14911                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14912                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14913                                 break; }
14914
14915                                 default: {
14916                                 break; }
14917
14918                         }
14919                 }
14920                 if (ndr_flags & NDR_BUFFERS) {
14921                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14922                         switch (level) {
14923                                 case 1:
14924                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14925                                 break;
14926
14927                                 case 2:
14928                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14929                                 break;
14930
14931                                 case 3:
14932                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14933                                 break;
14934
14935                                 case 4:
14936                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14937                                 break;
14938
14939                                 case 5:
14940                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14941                                 break;
14942
14943                                 case 6:
14944                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14945                                 break;
14946
14947                                 case 7:
14948                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14949                                 break;
14950
14951                                 case 8:
14952                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14953                                 break;
14954
14955                                 case 101:
14956                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14957                                 break;
14958
14959                                 default:
14960                                 break;
14961
14962                         }
14963                 }
14964                 ndr->flags = _flags_save_UNION;
14965         }
14966         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14967         return NDR_ERR_SUCCESS;
14968 }
14969
14970 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14971 {
14972         int level;
14973         {
14974                 uint32_t _flags_save_UNION = ndr->flags;
14975                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14976                 level = ndr_print_get_switch_value(ndr, r);
14977                 ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14978                 switch (level) {
14979                         case 1:
14980                                 ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14981                         break;
14982
14983                         case 2:
14984                                 ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14985                         break;
14986
14987                         case 3:
14988                                 ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14989                         break;
14990
14991                         case 4:
14992                                 ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14993                         break;
14994
14995                         case 5:
14996                                 ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14997                         break;
14998
14999                         case 6:
15000                                 ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
15001                         break;
15002
15003                         case 7:
15004                                 ndr_print_spoolss_DriverInfo7(ndr, "info7", &r->info7);
15005                         break;
15006
15007                         case 8:
15008                                 ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
15009                         break;
15010
15011                         case 101:
15012                                 ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
15013                         break;
15014
15015                         default:
15016                         break;
15017
15018                 }
15019                 ndr->flags = _flags_save_UNION;
15020         }
15021 }
15022
15023 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15024 {
15025         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15026         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
15027 }
15028
15029 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
15030 {
15031         if (ndr_flags & NDR_SCALARS) {
15032                 NDR_CHECK(ndr_push_align(ndr, 4));
15033                 {
15034                         uint32_t _flags_save_string = ndr->flags;
15035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15036                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15037                         ndr->flags = _flags_save_string;
15038                 }
15039                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15040         }
15041         if (ndr_flags & NDR_BUFFERS) {
15042         }
15043         return NDR_ERR_SUCCESS;
15044 }
15045
15046 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
15047 {
15048         if (ndr_flags & NDR_SCALARS) {
15049                 NDR_CHECK(ndr_pull_align(ndr, 4));
15050                 {
15051                         uint32_t _flags_save_string = ndr->flags;
15052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15053                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15054                         ndr->flags = _flags_save_string;
15055                 }
15056                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15057         }
15058         if (ndr_flags & NDR_BUFFERS) {
15059         }
15060         return NDR_ERR_SUCCESS;
15061 }
15062
15063 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
15064 {
15065         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
15066         ndr->depth++;
15067         ndr_print_string(ndr, "directory_name", r->directory_name);
15068         ndr->depth--;
15069 }
15070
15071 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15072 {
15073         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
15074 }
15075
15076 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
15077 {
15078         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15079         {
15080                 uint32_t _flags_save_UNION = ndr->flags;
15081                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15082                 if (ndr_flags & NDR_SCALARS) {
15083                         int level = ndr_push_get_switch_value(ndr, r);
15084                         NDR_CHECK(ndr_push_union_align(ndr, 4));
15085                         switch (level) {
15086                                 case 1: {
15087                                         NDR_CHECK(ndr_push_align(ndr, 4));
15088                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15089                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15090                                 break; }
15091
15092                                 default: {
15093                                         NDR_CHECK(ndr_push_align(ndr, 4));
15094                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15095                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15096                                 break; }
15097
15098                         }
15099                 }
15100                 if (ndr_flags & NDR_BUFFERS) {
15101                         int level = ndr_push_get_switch_value(ndr, r);
15102                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15103                         switch (level) {
15104                                 case 1:
15105                                 break;
15106
15107                                 default:
15108                                 break;
15109
15110                         }
15111                 }
15112                 ndr->flags = _flags_save_UNION;
15113         }
15114         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15115         return NDR_ERR_SUCCESS;
15116 }
15117
15118 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
15119 {
15120         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15121         int level;
15122         {
15123                 uint32_t _flags_save_UNION = ndr->flags;
15124                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15125                 level = ndr_pull_get_switch_value(ndr, r);
15126                 if (ndr_flags & NDR_SCALARS) {
15127                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
15128                         switch (level) {
15129                                 case 1: {
15130                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15131                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15132                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15133                                 break; }
15134
15135                                 default: {
15136                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15137                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15138                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15139                                 break; }
15140
15141                         }
15142                 }
15143                 if (ndr_flags & NDR_BUFFERS) {
15144                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15145                         switch (level) {
15146                                 case 1:
15147                                 break;
15148
15149                                 default:
15150                                 break;
15151
15152                         }
15153                 }
15154                 ndr->flags = _flags_save_UNION;
15155         }
15156         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15157         return NDR_ERR_SUCCESS;
15158 }
15159
15160 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
15161 {
15162         int level;
15163         {
15164                 uint32_t _flags_save_UNION = ndr->flags;
15165                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15166                 level = ndr_print_get_switch_value(ndr, r);
15167                 ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
15168                 switch (level) {
15169                         case 1:
15170                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15171                         break;
15172
15173                         default:
15174                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15175                         break;
15176
15177                 }
15178                 ndr->flags = _flags_save_UNION;
15179         }
15180 }
15181
15182 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15183 {
15184         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15185         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
15186 }
15187
15188 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
15189 {
15190         if (ndr_flags & NDR_SCALARS) {
15191                 NDR_CHECK(ndr_push_align(ndr, 5));
15192                 {
15193                         uint32_t _flags_save_string = ndr->flags;
15194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15195                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
15196                         ndr->flags = _flags_save_string;
15197                 }
15198                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15199         }
15200         if (ndr_flags & NDR_BUFFERS) {
15201                 {
15202                         uint32_t _flags_save_string = ndr->flags;
15203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15204                         if (r->print_processor_name) {
15205                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor_name));
15206                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
15207                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor_name));
15208                         }
15209                         ndr->flags = _flags_save_string;
15210                 }
15211         }
15212         return NDR_ERR_SUCCESS;
15213 }
15214
15215 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
15216 {
15217         uint32_t _ptr_print_processor_name;
15218         TALLOC_CTX *_mem_save_print_processor_name_0;
15219         if (ndr_flags & NDR_SCALARS) {
15220                 NDR_CHECK(ndr_pull_align(ndr, 5));
15221                 {
15222                         uint32_t _flags_save_string = ndr->flags;
15223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
15225                         if (_ptr_print_processor_name) {
15226                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
15227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
15228                         } else {
15229                                 r->print_processor_name = NULL;
15230                         }
15231                         ndr->flags = _flags_save_string;
15232                 }
15233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15234         }
15235         if (ndr_flags & NDR_BUFFERS) {
15236                 {
15237                         uint32_t _flags_save_string = ndr->flags;
15238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15239                         if (r->print_processor_name) {
15240                                 uint32_t _relative_save_offset;
15241                                 _relative_save_offset = ndr->offset;
15242                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
15243                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15244                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
15245                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
15246                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
15247                                 ndr->offset = _relative_save_offset;
15248                         }
15249                         ndr->flags = _flags_save_string;
15250                 }
15251         }
15252         return NDR_ERR_SUCCESS;
15253 }
15254
15255 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
15256 {
15257         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
15258         ndr->depth++;
15259         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
15260         ndr->depth++;
15261         if (r->print_processor_name) {
15262                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
15263         }
15264         ndr->depth--;
15265         ndr->depth--;
15266 }
15267
15268 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15269 {
15270         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
15271 }
15272
15273 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
15274 {
15275         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15276         {
15277                 uint32_t _flags_save_UNION = ndr->flags;
15278                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15279                 if (ndr_flags & NDR_SCALARS) {
15280                         int level = ndr_push_get_switch_value(ndr, r);
15281                         NDR_CHECK(ndr_push_union_align(ndr, 5));
15282                         switch (level) {
15283                                 case 1: {
15284                                         NDR_CHECK(ndr_push_align(ndr, 5));
15285                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15286                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15287                                 break; }
15288
15289                                 default: {
15290                                 break; }
15291
15292                         }
15293                 }
15294                 if (ndr_flags & NDR_BUFFERS) {
15295                         int level = ndr_push_get_switch_value(ndr, r);
15296                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15297                         switch (level) {
15298                                 case 1:
15299                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15300                                 break;
15301
15302                                 default:
15303                                 break;
15304
15305                         }
15306                 }
15307                 ndr->flags = _flags_save_UNION;
15308         }
15309         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15310         return NDR_ERR_SUCCESS;
15311 }
15312
15313 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
15314 {
15315         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15316         int level;
15317         {
15318                 uint32_t _flags_save_UNION = ndr->flags;
15319                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15320                 level = ndr_pull_get_switch_value(ndr, r);
15321                 if (ndr_flags & NDR_SCALARS) {
15322                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
15323                         switch (level) {
15324                                 case 1: {
15325                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15326                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15327                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15328                                 break; }
15329
15330                                 default: {
15331                                 break; }
15332
15333                         }
15334                 }
15335                 if (ndr_flags & NDR_BUFFERS) {
15336                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15337                         switch (level) {
15338                                 case 1:
15339                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15340                                 break;
15341
15342                                 default:
15343                                 break;
15344
15345                         }
15346                 }
15347                 ndr->flags = _flags_save_UNION;
15348         }
15349         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15350         return NDR_ERR_SUCCESS;
15351 }
15352
15353 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
15354 {
15355         int level;
15356         {
15357                 uint32_t _flags_save_UNION = ndr->flags;
15358                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15359                 level = ndr_print_get_switch_value(ndr, r);
15360                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
15361                 switch (level) {
15362                         case 1:
15363                                 ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
15364                         break;
15365
15366                         default:
15367                         break;
15368
15369                 }
15370                 ndr->flags = _flags_save_UNION;
15371         }
15372 }
15373
15374 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15375 {
15376         if (ndr_flags & NDR_SCALARS) {
15377                 NDR_CHECK(ndr_push_align(ndr, 4));
15378                 {
15379                         uint32_t _flags_save_string = ndr->flags;
15380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15381                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15382                         ndr->flags = _flags_save_string;
15383                 }
15384                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15385         }
15386         if (ndr_flags & NDR_BUFFERS) {
15387         }
15388         return NDR_ERR_SUCCESS;
15389 }
15390
15391 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15392 {
15393         if (ndr_flags & NDR_SCALARS) {
15394                 NDR_CHECK(ndr_pull_align(ndr, 4));
15395                 {
15396                         uint32_t _flags_save_string = ndr->flags;
15397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15398                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15399                         ndr->flags = _flags_save_string;
15400                 }
15401                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15402         }
15403         if (ndr_flags & NDR_BUFFERS) {
15404         }
15405         return NDR_ERR_SUCCESS;
15406 }
15407
15408 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15409 {
15410         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15411         ndr->depth++;
15412         ndr_print_string(ndr, "directory_name", r->directory_name);
15413         ndr->depth--;
15414 }
15415
15416 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15417 {
15418         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15419 }
15420
15421 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15422 {
15423         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15424         {
15425                 uint32_t _flags_save_UNION = ndr->flags;
15426                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15427                 if (ndr_flags & NDR_SCALARS) {
15428                         int level = ndr_push_get_switch_value(ndr, r);
15429                         NDR_CHECK(ndr_push_union_align(ndr, 4));
15430                         switch (level) {
15431                                 case 1: {
15432                                         NDR_CHECK(ndr_push_align(ndr, 4));
15433                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15434                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15435                                 break; }
15436
15437                                 default: {
15438                                         NDR_CHECK(ndr_push_align(ndr, 4));
15439                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15440                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15441                                 break; }
15442
15443                         }
15444                 }
15445                 if (ndr_flags & NDR_BUFFERS) {
15446                         int level = ndr_push_get_switch_value(ndr, r);
15447                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15448                         switch (level) {
15449                                 case 1:
15450                                 break;
15451
15452                                 default:
15453                                 break;
15454
15455                         }
15456                 }
15457                 ndr->flags = _flags_save_UNION;
15458         }
15459         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15460         return NDR_ERR_SUCCESS;
15461 }
15462
15463 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15464 {
15465         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15466         int level;
15467         {
15468                 uint32_t _flags_save_UNION = ndr->flags;
15469                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15470                 level = ndr_pull_get_switch_value(ndr, r);
15471                 if (ndr_flags & NDR_SCALARS) {
15472                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
15473                         switch (level) {
15474                                 case 1: {
15475                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15476                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15477                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15478                                 break; }
15479
15480                                 default: {
15481                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15482                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15483                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15484                                 break; }
15485
15486                         }
15487                 }
15488                 if (ndr_flags & NDR_BUFFERS) {
15489                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15490                         switch (level) {
15491                                 case 1:
15492                                 break;
15493
15494                                 default:
15495                                 break;
15496
15497                         }
15498                 }
15499                 ndr->flags = _flags_save_UNION;
15500         }
15501         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15502         return NDR_ERR_SUCCESS;
15503 }
15504
15505 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15506 {
15507         int level;
15508         {
15509                 uint32_t _flags_save_UNION = ndr->flags;
15510                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15511                 level = ndr_print_get_switch_value(ndr, r);
15512                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15513                 switch (level) {
15514                         case 1:
15515                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15516                         break;
15517
15518                         default:
15519                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15520                         break;
15521
15522                 }
15523                 ndr->flags = _flags_save_UNION;
15524         }
15525 }
15526
15527 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15528 {
15529         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15530         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15531 }
15532
15533 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15534 {
15535         if (ndr_flags & NDR_SCALARS) {
15536                 NDR_CHECK(ndr_push_align(ndr, 5));
15537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15539                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15540                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15541         }
15542         if (ndr_flags & NDR_BUFFERS) {
15543                 if (r->document_name) {
15544                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15545                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15547                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15548                 }
15549                 if (r->output_file) {
15550                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15551                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15552                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15553                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15554                 }
15555                 if (r->datatype) {
15556                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15557                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15559                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15560                 }
15561         }
15562         return NDR_ERR_SUCCESS;
15563 }
15564
15565 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15566 {
15567         uint32_t _ptr_document_name;
15568         uint32_t size_document_name_1 = 0;
15569         uint32_t length_document_name_1 = 0;
15570         TALLOC_CTX *_mem_save_document_name_0;
15571         uint32_t _ptr_output_file;
15572         uint32_t size_output_file_1 = 0;
15573         uint32_t length_output_file_1 = 0;
15574         TALLOC_CTX *_mem_save_output_file_0;
15575         uint32_t _ptr_datatype;
15576         uint32_t size_datatype_1 = 0;
15577         uint32_t length_datatype_1 = 0;
15578         TALLOC_CTX *_mem_save_datatype_0;
15579         if (ndr_flags & NDR_SCALARS) {
15580                 NDR_CHECK(ndr_pull_align(ndr, 5));
15581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15582                 if (_ptr_document_name) {
15583                         NDR_PULL_ALLOC(ndr, r->document_name);
15584                 } else {
15585                         r->document_name = NULL;
15586                 }
15587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15588                 if (_ptr_output_file) {
15589                         NDR_PULL_ALLOC(ndr, r->output_file);
15590                 } else {
15591                         r->output_file = NULL;
15592                 }
15593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15594                 if (_ptr_datatype) {
15595                         NDR_PULL_ALLOC(ndr, r->datatype);
15596                 } else {
15597                         r->datatype = NULL;
15598                 }
15599                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15600         }
15601         if (ndr_flags & NDR_BUFFERS) {
15602                 if (r->document_name) {
15603                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15604                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15605                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15606                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15607                         size_document_name_1 = ndr_get_array_size(ndr, &r->document_name);
15608                         length_document_name_1 = ndr_get_array_length(ndr, &r->document_name);
15609                         if (length_document_name_1 > size_document_name_1) {
15610                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_document_name_1, length_document_name_1);
15611                         }
15612                         NDR_CHECK(ndr_check_string_terminator(ndr, length_document_name_1, sizeof(uint16_t)));
15613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, length_document_name_1, sizeof(uint16_t), CH_UTF16));
15614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15615                 }
15616                 if (r->output_file) {
15617                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15618                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15621                         size_output_file_1 = ndr_get_array_size(ndr, &r->output_file);
15622                         length_output_file_1 = ndr_get_array_length(ndr, &r->output_file);
15623                         if (length_output_file_1 > size_output_file_1) {
15624                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_output_file_1, length_output_file_1);
15625                         }
15626                         NDR_CHECK(ndr_check_string_terminator(ndr, length_output_file_1, sizeof(uint16_t)));
15627                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, length_output_file_1, sizeof(uint16_t), CH_UTF16));
15628                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15629                 }
15630                 if (r->datatype) {
15631                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15632                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15633                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15634                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15635                         size_datatype_1 = ndr_get_array_size(ndr, &r->datatype);
15636                         length_datatype_1 = ndr_get_array_length(ndr, &r->datatype);
15637                         if (length_datatype_1 > size_datatype_1) {
15638                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_datatype_1, length_datatype_1);
15639                         }
15640                         NDR_CHECK(ndr_check_string_terminator(ndr, length_datatype_1, sizeof(uint16_t)));
15641                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, length_datatype_1, sizeof(uint16_t), CH_UTF16));
15642                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15643                 }
15644         }
15645         return NDR_ERR_SUCCESS;
15646 }
15647
15648 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15649 {
15650         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15651         ndr->depth++;
15652         ndr_print_ptr(ndr, "document_name", r->document_name);
15653         ndr->depth++;
15654         if (r->document_name) {
15655                 ndr_print_string(ndr, "document_name", r->document_name);
15656         }
15657         ndr->depth--;
15658         ndr_print_ptr(ndr, "output_file", r->output_file);
15659         ndr->depth++;
15660         if (r->output_file) {
15661                 ndr_print_string(ndr, "output_file", r->output_file);
15662         }
15663         ndr->depth--;
15664         ndr_print_ptr(ndr, "datatype", r->datatype);
15665         ndr->depth++;
15666         if (r->datatype) {
15667                 ndr_print_string(ndr, "datatype", r->datatype);
15668         }
15669         ndr->depth--;
15670         ndr->depth--;
15671 }
15672
15673 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15674 {
15675         if (ndr_flags & NDR_SCALARS) {
15676                 int level = ndr_push_get_switch_value(ndr, r);
15677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15678                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15679                 switch (level) {
15680                         case 1: {
15681                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15682                         break; }
15683
15684                         case 2: {
15685                         break; }
15686
15687                         case 3: {
15688                         break; }
15689
15690                         default: {
15691                         break; }
15692
15693                 }
15694         }
15695         if (ndr_flags & NDR_BUFFERS) {
15696                 int level = ndr_push_get_switch_value(ndr, r);
15697                 switch (level) {
15698                         case 1:
15699                                 if (r->info1) {
15700                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15701                                 }
15702                         break;
15703
15704                         case 2:
15705                         break;
15706
15707                         case 3:
15708                         break;
15709
15710                         default:
15711                         break;
15712
15713                 }
15714         }
15715         return NDR_ERR_SUCCESS;
15716 }
15717
15718 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15719 {
15720         int level;
15721         uint32_t _level;
15722         TALLOC_CTX *_mem_save_info1_0;
15723         uint32_t _ptr_info1;
15724         level = ndr_pull_get_switch_value(ndr, r);
15725         if (ndr_flags & NDR_SCALARS) {
15726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15727                 if (_level != level) {
15728                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15729                 }
15730                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15731                 switch (level) {
15732                         case 1: {
15733                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15734                                 if (_ptr_info1) {
15735                                         NDR_PULL_ALLOC(ndr, r->info1);
15736                                 } else {
15737                                         r->info1 = NULL;
15738                                 }
15739                         break; }
15740
15741                         case 2: {
15742                         break; }
15743
15744                         case 3: {
15745                         break; }
15746
15747                         default: {
15748                         break; }
15749
15750                 }
15751         }
15752         if (ndr_flags & NDR_BUFFERS) {
15753                 switch (level) {
15754                         case 1:
15755                                 if (r->info1) {
15756                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15757                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15758                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15759                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15760                                 }
15761                         break;
15762
15763                         case 2:
15764                         break;
15765
15766                         case 3:
15767                         break;
15768
15769                         default:
15770                         break;
15771
15772                 }
15773         }
15774         return NDR_ERR_SUCCESS;
15775 }
15776
15777 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15778 {
15779         int level;
15780         level = ndr_print_get_switch_value(ndr, r);
15781         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15782         switch (level) {
15783                 case 1:
15784                         ndr_print_ptr(ndr, "info1", r->info1);
15785                         ndr->depth++;
15786                         if (r->info1) {
15787                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15788                         }
15789                         ndr->depth--;
15790                 break;
15791
15792                 case 2:
15793                 break;
15794
15795                 case 3:
15796                 break;
15797
15798                 default:
15799                 break;
15800
15801         }
15802 }
15803
15804 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15805 {
15806         if (ndr_flags & NDR_SCALARS) {
15807                 NDR_CHECK(ndr_push_align(ndr, 4));
15808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15813                 {
15814                         uint32_t _flags_save_string = ndr->flags;
15815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15816                         {
15817                                 struct ndr_push *_ndr_extra_string;
15818                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15819                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15820                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15821                         }
15822                         ndr->flags = _flags_save_string;
15823                 }
15824                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15825         }
15826         if (ndr_flags & NDR_BUFFERS) {
15827         }
15828         return NDR_ERR_SUCCESS;
15829 }
15830
15831 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15832 {
15833         if (ndr_flags & NDR_SCALARS) {
15834                 NDR_CHECK(ndr_pull_align(ndr, 4));
15835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15840                 {
15841                         uint32_t _flags_save_string = ndr->flags;
15842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15843                         {
15844                                 struct ndr_pull *_ndr_extra_string;
15845                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15846                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15847                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15848                         }
15849                         ndr->flags = _flags_save_string;
15850                 }
15851                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15852         }
15853         if (ndr_flags & NDR_BUFFERS) {
15854         }
15855         return NDR_ERR_SUCCESS;
15856 }
15857
15858 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15859 {
15860         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15861         ndr->depth++;
15862         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);
15863         ndr_print_uint32(ndr, "major", r->major);
15864         ndr_print_uint32(ndr, "minor", r->minor);
15865         ndr_print_uint32(ndr, "build", r->build);
15866         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15867         ndr_print_string(ndr, "extra_string", r->extra_string);
15868         ndr->depth--;
15869 }
15870
15871 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15872 {
15873         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15874 }
15875
15876 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15877 {
15878         if (ndr_flags & NDR_SCALARS) {
15879                 NDR_CHECK(ndr_push_align(ndr, 4));
15880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15885                 {
15886                         uint32_t _flags_save_string = ndr->flags;
15887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15888                         {
15889                                 struct ndr_push *_ndr_extra_string;
15890                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15891                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15892                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15893                         }
15894                         ndr->flags = _flags_save_string;
15895                 }
15896                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15897                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15898                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15899                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15900                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15901                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15902         }
15903         if (ndr_flags & NDR_BUFFERS) {
15904         }
15905         return NDR_ERR_SUCCESS;
15906 }
15907
15908 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15909 {
15910         if (ndr_flags & NDR_SCALARS) {
15911                 NDR_CHECK(ndr_pull_align(ndr, 4));
15912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15917                 {
15918                         uint32_t _flags_save_string = ndr->flags;
15919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15920                         {
15921                                 struct ndr_pull *_ndr_extra_string;
15922                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15923                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15924                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15925                         }
15926                         ndr->flags = _flags_save_string;
15927                 }
15928                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15929                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15930                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15931                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15932                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15933                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15934         }
15935         if (ndr_flags & NDR_BUFFERS) {
15936         }
15937         return NDR_ERR_SUCCESS;
15938 }
15939
15940 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15941 {
15942         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15943         ndr->depth++;
15944         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);
15945         ndr_print_uint32(ndr, "major", r->major);
15946         ndr_print_uint32(ndr, "minor", r->minor);
15947         ndr_print_uint32(ndr, "build", r->build);
15948         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15949         ndr_print_string(ndr, "extra_string", r->extra_string);
15950         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15951         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15952         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15953         ndr_print_uint8(ndr, "product_type", r->product_type);
15954         ndr_print_uint8(ndr, "reserved", r->reserved);
15955         ndr->depth--;
15956 }
15957
15958 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15959 {
15960         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15961 }
15962
15963 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15964 {
15965         if (ndr_flags & NDR_SCALARS) {
15966                 int level = ndr_push_get_switch_value(ndr, r);
15967                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15968                 switch (level) {
15969                         case REG_NONE: {
15970                         break; }
15971
15972                         case REG_SZ: {
15973                                 {
15974                                         uint32_t _flags_save_string = ndr->flags;
15975                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15976                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15977                                         ndr->flags = _flags_save_string;
15978                                 }
15979                         break; }
15980
15981                         case REG_BINARY: {
15982                                 {
15983                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15984                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15985                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15986                                         ndr->flags = _flags_save_DATA_BLOB;
15987                                 }
15988                         break; }
15989
15990                         case REG_DWORD: {
15991                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15992                         break; }
15993
15994                         case REG_MULTI_SZ: {
15995                                 {
15996                                         uint32_t _flags_save_string_array = ndr->flags;
15997                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15998                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15999                                         ndr->flags = _flags_save_string_array;
16000                                 }
16001                         break; }
16002
16003                         default: {
16004                                 {
16005                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16006                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16007                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
16008                                         ndr->flags = _flags_save_DATA_BLOB;
16009                                 }
16010                         break; }
16011
16012                 }
16013         }
16014         if (ndr_flags & NDR_BUFFERS) {
16015                 int level = ndr_push_get_switch_value(ndr, r);
16016                 switch (level) {
16017                         case REG_NONE:
16018                         break;
16019
16020                         case REG_SZ:
16021                         break;
16022
16023                         case REG_BINARY:
16024                         break;
16025
16026                         case REG_DWORD:
16027                         break;
16028
16029                         case REG_MULTI_SZ:
16030                         break;
16031
16032                         default:
16033                         break;
16034
16035                 }
16036         }
16037         return NDR_ERR_SUCCESS;
16038 }
16039
16040 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
16041 {
16042         int level;
16043         level = ndr_pull_get_switch_value(ndr, r);
16044         if (ndr_flags & NDR_SCALARS) {
16045                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
16046                 switch (level) {
16047                         case REG_NONE: {
16048                         break; }
16049
16050                         case REG_SZ: {
16051                                 {
16052                                         uint32_t _flags_save_string = ndr->flags;
16053                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16054                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
16055                                         ndr->flags = _flags_save_string;
16056                                 }
16057                         break; }
16058
16059                         case REG_BINARY: {
16060                                 {
16061                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16062                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16063                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
16064                                         ndr->flags = _flags_save_DATA_BLOB;
16065                                 }
16066                         break; }
16067
16068                         case REG_DWORD: {
16069                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
16070                         break; }
16071
16072                         case REG_MULTI_SZ: {
16073                                 {
16074                                         uint32_t _flags_save_string_array = ndr->flags;
16075                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16076                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
16077                                         ndr->flags = _flags_save_string_array;
16078                                 }
16079                         break; }
16080
16081                         default: {
16082                                 {
16083                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16084                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16085                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
16086                                         ndr->flags = _flags_save_DATA_BLOB;
16087                                 }
16088                         break; }
16089
16090                 }
16091         }
16092         if (ndr_flags & NDR_BUFFERS) {
16093                 switch (level) {
16094                         case REG_NONE:
16095                         break;
16096
16097                         case REG_SZ:
16098                         break;
16099
16100                         case REG_BINARY:
16101                         break;
16102
16103                         case REG_DWORD:
16104                         break;
16105
16106                         case REG_MULTI_SZ:
16107                         break;
16108
16109                         default:
16110                         break;
16111
16112                 }
16113         }
16114         return NDR_ERR_SUCCESS;
16115 }
16116
16117 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
16118 {
16119         int level;
16120         level = ndr_print_get_switch_value(ndr, r);
16121         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
16122         switch (level) {
16123                 case REG_NONE:
16124                 break;
16125
16126                 case REG_SZ:
16127                         ndr_print_string(ndr, "string", r->string);
16128                 break;
16129
16130                 case REG_BINARY:
16131                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
16132                 break;
16133
16134                 case REG_DWORD:
16135                         ndr_print_uint32(ndr, "value", r->value);
16136                 break;
16137
16138                 case REG_MULTI_SZ:
16139                         ndr_print_string_array(ndr, "string_array", r->string_array);
16140                 break;
16141
16142                 default:
16143                         ndr_print_DATA_BLOB(ndr, "data", r->data);
16144                 break;
16145
16146         }
16147 }
16148
16149 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
16150 {
16151         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16152         return NDR_ERR_SUCCESS;
16153 }
16154
16155 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
16156 {
16157         uint32_t v;
16158         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16159         *r = v;
16160         return NDR_ERR_SUCCESS;
16161 }
16162
16163 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
16164 {
16165         const char *val = NULL;
16166
16167         switch (r) {
16168                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
16169                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
16170                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
16171         }
16172         ndr_print_enum(ndr, name, "ENUM", val, r);
16173 }
16174
16175 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
16176 {
16177         if (ndr_flags & NDR_SCALARS) {
16178                 NDR_CHECK(ndr_push_align(ndr, 4));
16179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
16180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
16181                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16182         }
16183         if (ndr_flags & NDR_BUFFERS) {
16184         }
16185         return NDR_ERR_SUCCESS;
16186 }
16187
16188 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
16189 {
16190         if (ndr_flags & NDR_SCALARS) {
16191                 NDR_CHECK(ndr_pull_align(ndr, 4));
16192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
16193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
16194                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16195         }
16196         if (ndr_flags & NDR_BUFFERS) {
16197         }
16198         return NDR_ERR_SUCCESS;
16199 }
16200
16201 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
16202 {
16203         ndr_print_struct(ndr, name, "spoolss_FormSize");
16204         ndr->depth++;
16205         ndr_print_uint32(ndr, "width", r->width);
16206         ndr_print_uint32(ndr, "height", r->height);
16207         ndr->depth--;
16208 }
16209
16210 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
16211 {
16212         if (ndr_flags & NDR_SCALARS) {
16213                 NDR_CHECK(ndr_push_align(ndr, 4));
16214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
16215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
16216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
16217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
16218                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16219         }
16220         if (ndr_flags & NDR_BUFFERS) {
16221         }
16222         return NDR_ERR_SUCCESS;
16223 }
16224
16225 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
16226 {
16227         if (ndr_flags & NDR_SCALARS) {
16228                 NDR_CHECK(ndr_pull_align(ndr, 4));
16229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
16230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
16231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
16232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
16233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16234         }
16235         if (ndr_flags & NDR_BUFFERS) {
16236         }
16237         return NDR_ERR_SUCCESS;
16238 }
16239
16240 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
16241 {
16242         ndr_print_struct(ndr, name, "spoolss_FormArea");
16243         ndr->depth++;
16244         ndr_print_uint32(ndr, "left", r->left);
16245         ndr_print_uint32(ndr, "top", r->top);
16246         ndr_print_uint32(ndr, "right", r->right);
16247         ndr_print_uint32(ndr, "bottom", r->bottom);
16248         ndr->depth--;
16249 }
16250
16251 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
16252 {
16253         if (ndr_flags & NDR_SCALARS) {
16254                 NDR_CHECK(ndr_push_align(ndr, 5));
16255                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16256                 {
16257                         uint32_t _flags_save_string = ndr->flags;
16258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16260                         ndr->flags = _flags_save_string;
16261                 }
16262                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16263                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16264                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16265         }
16266         if (ndr_flags & NDR_BUFFERS) {
16267                 {
16268                         uint32_t _flags_save_string = ndr->flags;
16269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16270                         if (r->form_name) {
16271                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16272                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16273                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16274                         }
16275                         ndr->flags = _flags_save_string;
16276                 }
16277         }
16278         return NDR_ERR_SUCCESS;
16279 }
16280
16281 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
16282 {
16283         uint32_t _ptr_form_name;
16284         TALLOC_CTX *_mem_save_form_name_0;
16285         if (ndr_flags & NDR_SCALARS) {
16286                 NDR_CHECK(ndr_pull_align(ndr, 5));
16287                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16288                 {
16289                         uint32_t _flags_save_string = ndr->flags;
16290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16291                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16292                         if (_ptr_form_name) {
16293                                 NDR_PULL_ALLOC(ndr, r->form_name);
16294                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16295                         } else {
16296                                 r->form_name = NULL;
16297                         }
16298                         ndr->flags = _flags_save_string;
16299                 }
16300                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16301                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16302                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16303         }
16304         if (ndr_flags & NDR_BUFFERS) {
16305                 {
16306                         uint32_t _flags_save_string = ndr->flags;
16307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16308                         if (r->form_name) {
16309                                 uint32_t _relative_save_offset;
16310                                 _relative_save_offset = ndr->offset;
16311                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16312                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16313                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16314                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16315                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16316                                 ndr->offset = _relative_save_offset;
16317                         }
16318                         ndr->flags = _flags_save_string;
16319                 }
16320         }
16321         return NDR_ERR_SUCCESS;
16322 }
16323
16324 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
16325 {
16326         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
16327         ndr->depth++;
16328         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16329         ndr_print_ptr(ndr, "form_name", r->form_name);
16330         ndr->depth++;
16331         if (r->form_name) {
16332                 ndr_print_string(ndr, "form_name", r->form_name);
16333         }
16334         ndr->depth--;
16335         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16336         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16337         ndr->depth--;
16338 }
16339
16340 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16341 {
16342         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
16343 }
16344
16345 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16346 {
16347         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16348         return NDR_ERR_SUCCESS;
16349 }
16350
16351 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16352 {
16353         uint32_t v;
16354         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16355         *r = v;
16356         return NDR_ERR_SUCCESS;
16357 }
16358
16359 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
16360 {
16361         ndr_print_uint32(ndr, name, r);
16362         ndr->depth++;
16363         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
16364         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
16365         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
16366         ndr->depth--;
16367 }
16368
16369 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
16370 {
16371         if (ndr_flags & NDR_SCALARS) {
16372                 NDR_CHECK(ndr_push_align(ndr, 5));
16373                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16374                 {
16375                         uint32_t _flags_save_string = ndr->flags;
16376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16377                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16378                         ndr->flags = _flags_save_string;
16379                 }
16380                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16381                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16382                 {
16383                         uint32_t _flags_save_string = ndr->flags;
16384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16385                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
16386                         ndr->flags = _flags_save_string;
16387                 }
16388                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16389                 {
16390                         uint32_t _flags_save_string = ndr->flags;
16391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16392                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
16393                         ndr->flags = _flags_save_string;
16394                 }
16395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16396                 {
16397                         uint32_t _flags_save_string = ndr->flags;
16398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16399                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
16400                         ndr->flags = _flags_save_string;
16401                 }
16402                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
16403                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
16404                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16405         }
16406         if (ndr_flags & NDR_BUFFERS) {
16407                 {
16408                         uint32_t _flags_save_string = ndr->flags;
16409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16410                         if (r->form_name) {
16411                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16412                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16413                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16414                         }
16415                         ndr->flags = _flags_save_string;
16416                 }
16417                 {
16418                         uint32_t _flags_save_string = ndr->flags;
16419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16420                         if (r->keyword) {
16421                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->keyword));
16422                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16423                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->keyword));
16424                         }
16425                         ndr->flags = _flags_save_string;
16426                 }
16427                 {
16428                         uint32_t _flags_save_string = ndr->flags;
16429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16430                         if (r->mui_dll) {
16431                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->mui_dll));
16432                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16433                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->mui_dll));
16434                         }
16435                         ndr->flags = _flags_save_string;
16436                 }
16437                 {
16438                         uint32_t _flags_save_string = ndr->flags;
16439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16440                         if (r->display_name) {
16441                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
16442                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16443                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
16444                         }
16445                         ndr->flags = _flags_save_string;
16446                 }
16447         }
16448         return NDR_ERR_SUCCESS;
16449 }
16450
16451 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16452 {
16453         uint32_t _ptr_form_name;
16454         TALLOC_CTX *_mem_save_form_name_0;
16455         uint32_t _ptr_keyword;
16456         TALLOC_CTX *_mem_save_keyword_0;
16457         uint32_t _ptr_mui_dll;
16458         TALLOC_CTX *_mem_save_mui_dll_0;
16459         uint32_t _ptr_display_name;
16460         TALLOC_CTX *_mem_save_display_name_0;
16461         if (ndr_flags & NDR_SCALARS) {
16462                 NDR_CHECK(ndr_pull_align(ndr, 5));
16463                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16464                 {
16465                         uint32_t _flags_save_string = ndr->flags;
16466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16467                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16468                         if (_ptr_form_name) {
16469                                 NDR_PULL_ALLOC(ndr, r->form_name);
16470                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16471                         } else {
16472                                 r->form_name = NULL;
16473                         }
16474                         ndr->flags = _flags_save_string;
16475                 }
16476                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16477                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16478                 {
16479                         uint32_t _flags_save_string = ndr->flags;
16480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16481                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16482                         if (_ptr_keyword) {
16483                                 NDR_PULL_ALLOC(ndr, r->keyword);
16484                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16485                         } else {
16486                                 r->keyword = NULL;
16487                         }
16488                         ndr->flags = _flags_save_string;
16489                 }
16490                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16491                 {
16492                         uint32_t _flags_save_string = ndr->flags;
16493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16494                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16495                         if (_ptr_mui_dll) {
16496                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16497                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16498                         } else {
16499                                 r->mui_dll = NULL;
16500                         }
16501                         ndr->flags = _flags_save_string;
16502                 }
16503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16504                 {
16505                         uint32_t _flags_save_string = ndr->flags;
16506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16507                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16508                         if (_ptr_display_name) {
16509                                 NDR_PULL_ALLOC(ndr, r->display_name);
16510                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16511                         } else {
16512                                 r->display_name = NULL;
16513                         }
16514                         ndr->flags = _flags_save_string;
16515                 }
16516                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16517                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16518                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16519         }
16520         if (ndr_flags & NDR_BUFFERS) {
16521                 {
16522                         uint32_t _flags_save_string = ndr->flags;
16523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16524                         if (r->form_name) {
16525                                 uint32_t _relative_save_offset;
16526                                 _relative_save_offset = ndr->offset;
16527                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16528                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16529                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16530                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16531                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16532                                 ndr->offset = _relative_save_offset;
16533                         }
16534                         ndr->flags = _flags_save_string;
16535                 }
16536                 {
16537                         uint32_t _flags_save_string = ndr->flags;
16538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16539                         if (r->keyword) {
16540                                 uint32_t _relative_save_offset;
16541                                 _relative_save_offset = ndr->offset;
16542                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16543                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16544                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16545                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16546                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16547                                 ndr->offset = _relative_save_offset;
16548                         }
16549                         ndr->flags = _flags_save_string;
16550                 }
16551                 {
16552                         uint32_t _flags_save_string = ndr->flags;
16553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16554                         if (r->mui_dll) {
16555                                 uint32_t _relative_save_offset;
16556                                 _relative_save_offset = ndr->offset;
16557                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16558                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16559                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16560                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16561                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16562                                 ndr->offset = _relative_save_offset;
16563                         }
16564                         ndr->flags = _flags_save_string;
16565                 }
16566                 {
16567                         uint32_t _flags_save_string = ndr->flags;
16568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16569                         if (r->display_name) {
16570                                 uint32_t _relative_save_offset;
16571                                 _relative_save_offset = ndr->offset;
16572                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16573                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16574                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16575                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16576                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16577                                 ndr->offset = _relative_save_offset;
16578                         }
16579                         ndr->flags = _flags_save_string;
16580                 }
16581         }
16582         return NDR_ERR_SUCCESS;
16583 }
16584
16585 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16586 {
16587         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16588         ndr->depth++;
16589         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16590         ndr_print_ptr(ndr, "form_name", r->form_name);
16591         ndr->depth++;
16592         if (r->form_name) {
16593                 ndr_print_string(ndr, "form_name", r->form_name);
16594         }
16595         ndr->depth--;
16596         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16597         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16598         ndr_print_ptr(ndr, "keyword", r->keyword);
16599         ndr->depth++;
16600         if (r->keyword) {
16601                 ndr_print_string(ndr, "keyword", r->keyword);
16602         }
16603         ndr->depth--;
16604         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16605         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16606         ndr->depth++;
16607         if (r->mui_dll) {
16608                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16609         }
16610         ndr->depth--;
16611         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16612         ndr_print_ptr(ndr, "display_name", r->display_name);
16613         ndr->depth++;
16614         if (r->display_name) {
16615                 ndr_print_string(ndr, "display_name", r->display_name);
16616         }
16617         ndr->depth--;
16618         ndr_print_uint16(ndr, "lang_id", r->lang_id);
16619         ndr_print_uint16(ndr, "unused", r->unused);
16620         ndr->depth--;
16621 }
16622
16623 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16624 {
16625         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16626 }
16627
16628 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16629 {
16630         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16631         {
16632                 uint32_t _flags_save_UNION = ndr->flags;
16633                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16634                 if (ndr_flags & NDR_SCALARS) {
16635                         int level = ndr_push_get_switch_value(ndr, r);
16636                         NDR_CHECK(ndr_push_union_align(ndr, 5));
16637                         switch (level) {
16638                                 case 1: {
16639                                         NDR_CHECK(ndr_push_align(ndr, 5));
16640                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16641                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16642                                 break; }
16643
16644                                 case 2: {
16645                                         NDR_CHECK(ndr_push_align(ndr, 5));
16646                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16647                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16648                                 break; }
16649
16650                                 default: {
16651                                 break; }
16652
16653                         }
16654                 }
16655                 if (ndr_flags & NDR_BUFFERS) {
16656                         int level = ndr_push_get_switch_value(ndr, r);
16657                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16658                         switch (level) {
16659                                 case 1:
16660                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16661                                 break;
16662
16663                                 case 2:
16664                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16665                                 break;
16666
16667                                 default:
16668                                 break;
16669
16670                         }
16671                 }
16672                 ndr->flags = _flags_save_UNION;
16673         }
16674         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16675         return NDR_ERR_SUCCESS;
16676 }
16677
16678 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16679 {
16680         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16681         int level;
16682         {
16683                 uint32_t _flags_save_UNION = ndr->flags;
16684                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16685                 level = ndr_pull_get_switch_value(ndr, r);
16686                 if (ndr_flags & NDR_SCALARS) {
16687                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
16688                         switch (level) {
16689                                 case 1: {
16690                                         NDR_CHECK(ndr_pull_align(ndr, 5));
16691                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16692                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16693                                 break; }
16694
16695                                 case 2: {
16696                                         NDR_CHECK(ndr_pull_align(ndr, 5));
16697                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16698                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16699                                 break; }
16700
16701                                 default: {
16702                                 break; }
16703
16704                         }
16705                 }
16706                 if (ndr_flags & NDR_BUFFERS) {
16707                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16708                         switch (level) {
16709                                 case 1:
16710                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16711                                 break;
16712
16713                                 case 2:
16714                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16715                                 break;
16716
16717                                 default:
16718                                 break;
16719
16720                         }
16721                 }
16722                 ndr->flags = _flags_save_UNION;
16723         }
16724         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16725         return NDR_ERR_SUCCESS;
16726 }
16727
16728 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16729 {
16730         int level;
16731         {
16732                 uint32_t _flags_save_UNION = ndr->flags;
16733                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16734                 level = ndr_print_get_switch_value(ndr, r);
16735                 ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16736                 switch (level) {
16737                         case 1:
16738                                 ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16739                         break;
16740
16741                         case 2:
16742                                 ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16743                         break;
16744
16745                         default:
16746                         break;
16747
16748                 }
16749                 ndr->flags = _flags_save_UNION;
16750         }
16751 }
16752
16753 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16754 {
16755         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
16756         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16757 }
16758
16759 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16760 {
16761         if (ndr_flags & NDR_SCALARS) {
16762                 NDR_CHECK(ndr_push_align(ndr, 5));
16763                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16764                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16765                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16766                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16767                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16768         }
16769         if (ndr_flags & NDR_BUFFERS) {
16770                 if (r->form_name) {
16771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16774                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16775                 }
16776         }
16777         return NDR_ERR_SUCCESS;
16778 }
16779
16780 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16781 {
16782         uint32_t _ptr_form_name;
16783         uint32_t size_form_name_1 = 0;
16784         uint32_t length_form_name_1 = 0;
16785         TALLOC_CTX *_mem_save_form_name_0;
16786         if (ndr_flags & NDR_SCALARS) {
16787                 NDR_CHECK(ndr_pull_align(ndr, 5));
16788                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16790                 if (_ptr_form_name) {
16791                         NDR_PULL_ALLOC(ndr, r->form_name);
16792                 } else {
16793                         r->form_name = NULL;
16794                 }
16795                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16796                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16797                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16798         }
16799         if (ndr_flags & NDR_BUFFERS) {
16800                 if (r->form_name) {
16801                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16802                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16805                         size_form_name_1 = ndr_get_array_size(ndr, &r->form_name);
16806                         length_form_name_1 = ndr_get_array_length(ndr, &r->form_name);
16807                         if (length_form_name_1 > size_form_name_1) {
16808                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_form_name_1, length_form_name_1);
16809                         }
16810                         NDR_CHECK(ndr_check_string_terminator(ndr, length_form_name_1, sizeof(uint16_t)));
16811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, length_form_name_1, sizeof(uint16_t), CH_UTF16));
16812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16813                 }
16814         }
16815         return NDR_ERR_SUCCESS;
16816 }
16817
16818 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16819 {
16820         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16821         ndr->depth++;
16822         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16823         ndr_print_ptr(ndr, "form_name", r->form_name);
16824         ndr->depth++;
16825         if (r->form_name) {
16826                 ndr_print_string(ndr, "form_name", r->form_name);
16827         }
16828         ndr->depth--;
16829         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16830         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16831         ndr->depth--;
16832 }
16833
16834 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16835 {
16836         if (ndr_flags & NDR_SCALARS) {
16837                 NDR_CHECK(ndr_push_align(ndr, 5));
16838                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16839                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16840                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16841                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16843                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16844                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16848                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16849         }
16850         if (ndr_flags & NDR_BUFFERS) {
16851                 if (r->form_name) {
16852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16856                 }
16857                 if (r->keyword) {
16858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16862                 }
16863                 if (r->mui_dll) {
16864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16868                 }
16869                 if (r->display_name) {
16870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16874                 }
16875         }
16876         return NDR_ERR_SUCCESS;
16877 }
16878
16879 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16880 {
16881         uint32_t _ptr_form_name;
16882         uint32_t size_form_name_1 = 0;
16883         uint32_t length_form_name_1 = 0;
16884         TALLOC_CTX *_mem_save_form_name_0;
16885         uint32_t _ptr_keyword;
16886         uint32_t size_keyword_1 = 0;
16887         uint32_t length_keyword_1 = 0;
16888         TALLOC_CTX *_mem_save_keyword_0;
16889         uint32_t _ptr_mui_dll;
16890         uint32_t size_mui_dll_1 = 0;
16891         uint32_t length_mui_dll_1 = 0;
16892         TALLOC_CTX *_mem_save_mui_dll_0;
16893         uint32_t _ptr_display_name;
16894         uint32_t size_display_name_1 = 0;
16895         uint32_t length_display_name_1 = 0;
16896         TALLOC_CTX *_mem_save_display_name_0;
16897         if (ndr_flags & NDR_SCALARS) {
16898                 NDR_CHECK(ndr_pull_align(ndr, 5));
16899                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16901                 if (_ptr_form_name) {
16902                         NDR_PULL_ALLOC(ndr, r->form_name);
16903                 } else {
16904                         r->form_name = NULL;
16905                 }
16906                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16907                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16909                 if (_ptr_keyword) {
16910                         NDR_PULL_ALLOC(ndr, r->keyword);
16911                 } else {
16912                         r->keyword = NULL;
16913                 }
16914                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16916                 if (_ptr_mui_dll) {
16917                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16918                 } else {
16919                         r->mui_dll = NULL;
16920                 }
16921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16923                 if (_ptr_display_name) {
16924                         NDR_PULL_ALLOC(ndr, r->display_name);
16925                 } else {
16926                         r->display_name = NULL;
16927                 }
16928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16929                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16930         }
16931         if (ndr_flags & NDR_BUFFERS) {
16932                 if (r->form_name) {
16933                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16934                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16937                         size_form_name_1 = ndr_get_array_size(ndr, &r->form_name);
16938                         length_form_name_1 = ndr_get_array_length(ndr, &r->form_name);
16939                         if (length_form_name_1 > size_form_name_1) {
16940                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_form_name_1, length_form_name_1);
16941                         }
16942                         NDR_CHECK(ndr_check_string_terminator(ndr, length_form_name_1, sizeof(uint16_t)));
16943                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, length_form_name_1, sizeof(uint16_t), CH_UTF16));
16944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16945                 }
16946                 if (r->keyword) {
16947                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16948                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16949                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16950                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16951                         size_keyword_1 = ndr_get_array_size(ndr, &r->keyword);
16952                         length_keyword_1 = ndr_get_array_length(ndr, &r->keyword);
16953                         if (length_keyword_1 > size_keyword_1) {
16954                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_keyword_1, length_keyword_1);
16955                         }
16956                         NDR_CHECK(ndr_check_string_terminator(ndr, length_keyword_1, sizeof(uint8_t)));
16957                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, length_keyword_1, sizeof(uint8_t), CH_DOS));
16958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16959                 }
16960                 if (r->mui_dll) {
16961                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16962                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16965                         size_mui_dll_1 = ndr_get_array_size(ndr, &r->mui_dll);
16966                         length_mui_dll_1 = ndr_get_array_length(ndr, &r->mui_dll);
16967                         if (length_mui_dll_1 > size_mui_dll_1) {
16968                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_mui_dll_1, length_mui_dll_1);
16969                         }
16970                         NDR_CHECK(ndr_check_string_terminator(ndr, length_mui_dll_1, sizeof(uint16_t)));
16971                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, length_mui_dll_1, sizeof(uint16_t), CH_UTF16));
16972                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16973                 }
16974                 if (r->display_name) {
16975                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16976                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16977                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16978                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16979                         size_display_name_1 = ndr_get_array_size(ndr, &r->display_name);
16980                         length_display_name_1 = ndr_get_array_length(ndr, &r->display_name);
16981                         if (length_display_name_1 > size_display_name_1) {
16982                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_display_name_1, length_display_name_1);
16983                         }
16984                         NDR_CHECK(ndr_check_string_terminator(ndr, length_display_name_1, sizeof(uint16_t)));
16985                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, length_display_name_1, sizeof(uint16_t), CH_UTF16));
16986                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16987                 }
16988         }
16989         return NDR_ERR_SUCCESS;
16990 }
16991
16992 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16993 {
16994         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16995         ndr->depth++;
16996         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16997         ndr_print_ptr(ndr, "form_name", r->form_name);
16998         ndr->depth++;
16999         if (r->form_name) {
17000                 ndr_print_string(ndr, "form_name", r->form_name);
17001         }
17002         ndr->depth--;
17003         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
17004         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
17005         ndr_print_ptr(ndr, "keyword", r->keyword);
17006         ndr->depth++;
17007         if (r->keyword) {
17008                 ndr_print_string(ndr, "keyword", r->keyword);
17009         }
17010         ndr->depth--;
17011         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
17012         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
17013         ndr->depth++;
17014         if (r->mui_dll) {
17015                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
17016         }
17017         ndr->depth--;
17018         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
17019         ndr_print_ptr(ndr, "display_name", r->display_name);
17020         ndr->depth++;
17021         if (r->display_name) {
17022                 ndr_print_string(ndr, "display_name", r->display_name);
17023         }
17024         ndr->depth--;
17025         ndr_print_uint32(ndr, "lang_id", r->lang_id);
17026         ndr->depth--;
17027 }
17028
17029 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
17030 {
17031         if (ndr_flags & NDR_SCALARS) {
17032                 int level = ndr_push_get_switch_value(ndr, r);
17033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17034                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17035                 switch (level) {
17036                         case 1: {
17037                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
17038                         break; }
17039
17040                         case 2: {
17041                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
17042                         break; }
17043
17044                         default:
17045                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17046                 }
17047         }
17048         if (ndr_flags & NDR_BUFFERS) {
17049                 int level = ndr_push_get_switch_value(ndr, r);
17050                 switch (level) {
17051                         case 1:
17052                                 if (r->info1) {
17053                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17054                                 }
17055                         break;
17056
17057                         case 2:
17058                                 if (r->info2) {
17059                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17060                                 }
17061                         break;
17062
17063                         default:
17064                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17065                 }
17066         }
17067         return NDR_ERR_SUCCESS;
17068 }
17069
17070 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
17071 {
17072         int level;
17073         uint32_t _level;
17074         TALLOC_CTX *_mem_save_info1_0;
17075         uint32_t _ptr_info1;
17076         TALLOC_CTX *_mem_save_info2_0;
17077         uint32_t _ptr_info2;
17078         level = ndr_pull_get_switch_value(ndr, r);
17079         if (ndr_flags & NDR_SCALARS) {
17080                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17081                 if (_level != level) {
17082                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
17083                 }
17084                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17085                 switch (level) {
17086                         case 1: {
17087                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
17088                                 if (_ptr_info1) {
17089                                         NDR_PULL_ALLOC(ndr, r->info1);
17090                                 } else {
17091                                         r->info1 = NULL;
17092                                 }
17093                         break; }
17094
17095                         case 2: {
17096                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
17097                                 if (_ptr_info2) {
17098                                         NDR_PULL_ALLOC(ndr, r->info2);
17099                                 } else {
17100                                         r->info2 = NULL;
17101                                 }
17102                         break; }
17103
17104                         default:
17105                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17106                 }
17107         }
17108         if (ndr_flags & NDR_BUFFERS) {
17109                 switch (level) {
17110                         case 1:
17111                                 if (r->info1) {
17112                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
17113                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
17114                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17115                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
17116                                 }
17117                         break;
17118
17119                         case 2:
17120                                 if (r->info2) {
17121                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
17122                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
17123                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17124                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
17125                                 }
17126                         break;
17127
17128                         default:
17129                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17130                 }
17131         }
17132         return NDR_ERR_SUCCESS;
17133 }
17134
17135 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
17136 {
17137         int level;
17138         level = ndr_print_get_switch_value(ndr, r);
17139         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
17140         switch (level) {
17141                 case 1:
17142                         ndr_print_ptr(ndr, "info1", r->info1);
17143                         ndr->depth++;
17144                         if (r->info1) {
17145                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
17146                         }
17147                         ndr->depth--;
17148                 break;
17149
17150                 case 2:
17151                         ndr_print_ptr(ndr, "info2", r->info2);
17152                         ndr->depth++;
17153                         if (r->info2) {
17154                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
17155                         }
17156                         ndr->depth--;
17157                 break;
17158
17159                 default:
17160                         ndr_print_bad_level(ndr, name, level);
17161         }
17162 }
17163
17164 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
17165 {
17166         if (ndr_flags & NDR_SCALARS) {
17167                 NDR_CHECK(ndr_push_align(ndr, 5));
17168                 {
17169                         uint32_t _flags_save_string = ndr->flags;
17170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17171                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17172                         ndr->flags = _flags_save_string;
17173                 }
17174                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17175         }
17176         if (ndr_flags & NDR_BUFFERS) {
17177                 {
17178                         uint32_t _flags_save_string = ndr->flags;
17179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17180                         if (r->port_name) {
17181                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17182                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17183                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17184                         }
17185                         ndr->flags = _flags_save_string;
17186                 }
17187         }
17188         return NDR_ERR_SUCCESS;
17189 }
17190
17191 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
17192 {
17193         uint32_t _ptr_port_name;
17194         TALLOC_CTX *_mem_save_port_name_0;
17195         if (ndr_flags & NDR_SCALARS) {
17196                 NDR_CHECK(ndr_pull_align(ndr, 5));
17197                 {
17198                         uint32_t _flags_save_string = ndr->flags;
17199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17200                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17201                         if (_ptr_port_name) {
17202                                 NDR_PULL_ALLOC(ndr, r->port_name);
17203                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17204                         } else {
17205                                 r->port_name = NULL;
17206                         }
17207                         ndr->flags = _flags_save_string;
17208                 }
17209                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17210         }
17211         if (ndr_flags & NDR_BUFFERS) {
17212                 {
17213                         uint32_t _flags_save_string = ndr->flags;
17214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17215                         if (r->port_name) {
17216                                 uint32_t _relative_save_offset;
17217                                 _relative_save_offset = ndr->offset;
17218                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17219                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17220                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17221                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17222                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17223                                 ndr->offset = _relative_save_offset;
17224                         }
17225                         ndr->flags = _flags_save_string;
17226                 }
17227         }
17228         return NDR_ERR_SUCCESS;
17229 }
17230
17231 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
17232 {
17233         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
17234         ndr->depth++;
17235         ndr_print_ptr(ndr, "port_name", r->port_name);
17236         ndr->depth++;
17237         if (r->port_name) {
17238                 ndr_print_string(ndr, "port_name", r->port_name);
17239         }
17240         ndr->depth--;
17241         ndr->depth--;
17242 }
17243
17244 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17245 {
17246         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
17247 }
17248
17249 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17250 {
17251         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17252         return NDR_ERR_SUCCESS;
17253 }
17254
17255 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17256 {
17257         uint32_t v;
17258         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17259         *r = v;
17260         return NDR_ERR_SUCCESS;
17261 }
17262
17263 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
17264 {
17265         ndr_print_uint32(ndr, name, r);
17266         ndr->depth++;
17267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
17268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
17269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
17270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
17271         ndr->depth--;
17272 }
17273
17274 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
17275 {
17276         if (ndr_flags & NDR_SCALARS) {
17277                 NDR_CHECK(ndr_push_align(ndr, 5));
17278                 {
17279                         uint32_t _flags_save_string = ndr->flags;
17280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17281                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17282                         ndr->flags = _flags_save_string;
17283                 }
17284                 {
17285                         uint32_t _flags_save_string = ndr->flags;
17286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17287                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17288                         ndr->flags = _flags_save_string;
17289                 }
17290                 {
17291                         uint32_t _flags_save_string = ndr->flags;
17292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17293                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
17294                         ndr->flags = _flags_save_string;
17295                 }
17296                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
17297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
17298                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17299         }
17300         if (ndr_flags & NDR_BUFFERS) {
17301                 {
17302                         uint32_t _flags_save_string = ndr->flags;
17303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17304                         if (r->port_name) {
17305                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17306                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17307                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17308                         }
17309                         ndr->flags = _flags_save_string;
17310                 }
17311                 {
17312                         uint32_t _flags_save_string = ndr->flags;
17313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17314                         if (r->monitor_name) {
17315                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17316                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17317                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17318                         }
17319                         ndr->flags = _flags_save_string;
17320                 }
17321                 {
17322                         uint32_t _flags_save_string = ndr->flags;
17323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17324                         if (r->description) {
17325                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
17326                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
17327                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
17328                         }
17329                         ndr->flags = _flags_save_string;
17330                 }
17331         }
17332         return NDR_ERR_SUCCESS;
17333 }
17334
17335 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
17336 {
17337         uint32_t _ptr_port_name;
17338         TALLOC_CTX *_mem_save_port_name_0;
17339         uint32_t _ptr_monitor_name;
17340         TALLOC_CTX *_mem_save_monitor_name_0;
17341         uint32_t _ptr_description;
17342         TALLOC_CTX *_mem_save_description_0;
17343         if (ndr_flags & NDR_SCALARS) {
17344                 NDR_CHECK(ndr_pull_align(ndr, 5));
17345                 {
17346                         uint32_t _flags_save_string = ndr->flags;
17347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17348                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17349                         if (_ptr_port_name) {
17350                                 NDR_PULL_ALLOC(ndr, r->port_name);
17351                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17352                         } else {
17353                                 r->port_name = NULL;
17354                         }
17355                         ndr->flags = _flags_save_string;
17356                 }
17357                 {
17358                         uint32_t _flags_save_string = ndr->flags;
17359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17360                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17361                         if (_ptr_monitor_name) {
17362                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17363                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17364                         } else {
17365                                 r->monitor_name = NULL;
17366                         }
17367                         ndr->flags = _flags_save_string;
17368                 }
17369                 {
17370                         uint32_t _flags_save_string = ndr->flags;
17371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17372                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
17373                         if (_ptr_description) {
17374                                 NDR_PULL_ALLOC(ndr, r->description);
17375                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
17376                         } else {
17377                                 r->description = NULL;
17378                         }
17379                         ndr->flags = _flags_save_string;
17380                 }
17381                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
17382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
17383                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17384         }
17385         if (ndr_flags & NDR_BUFFERS) {
17386                 {
17387                         uint32_t _flags_save_string = ndr->flags;
17388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17389                         if (r->port_name) {
17390                                 uint32_t _relative_save_offset;
17391                                 _relative_save_offset = ndr->offset;
17392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17393                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17394                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17397                                 ndr->offset = _relative_save_offset;
17398                         }
17399                         ndr->flags = _flags_save_string;
17400                 }
17401                 {
17402                         uint32_t _flags_save_string = ndr->flags;
17403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17404                         if (r->monitor_name) {
17405                                 uint32_t _relative_save_offset;
17406                                 _relative_save_offset = ndr->offset;
17407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17408                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17409                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17410                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17412                                 ndr->offset = _relative_save_offset;
17413                         }
17414                         ndr->flags = _flags_save_string;
17415                 }
17416                 {
17417                         uint32_t _flags_save_string = ndr->flags;
17418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17419                         if (r->description) {
17420                                 uint32_t _relative_save_offset;
17421                                 _relative_save_offset = ndr->offset;
17422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
17423                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
17424                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
17425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
17426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
17427                                 ndr->offset = _relative_save_offset;
17428                         }
17429                         ndr->flags = _flags_save_string;
17430                 }
17431         }
17432         return NDR_ERR_SUCCESS;
17433 }
17434
17435 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17436 {
17437         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17438         ndr->depth++;
17439         ndr_print_ptr(ndr, "port_name", r->port_name);
17440         ndr->depth++;
17441         if (r->port_name) {
17442                 ndr_print_string(ndr, "port_name", r->port_name);
17443         }
17444         ndr->depth--;
17445         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17446         ndr->depth++;
17447         if (r->monitor_name) {
17448                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17449         }
17450         ndr->depth--;
17451         ndr_print_ptr(ndr, "description", r->description);
17452         ndr->depth++;
17453         if (r->description) {
17454                 ndr_print_string(ndr, "description", r->description);
17455         }
17456         ndr->depth--;
17457         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17458         ndr_print_uint32(ndr, "reserved", r->reserved);
17459         ndr->depth--;
17460 }
17461
17462 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17463 {
17464         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17465 }
17466
17467 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17468 {
17469         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17470         return NDR_ERR_SUCCESS;
17471 }
17472
17473 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17474 {
17475         uint32_t v;
17476         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17477         *r = v;
17478         return NDR_ERR_SUCCESS;
17479 }
17480
17481 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17482 {
17483         const char *val = NULL;
17484
17485         switch (r) {
17486                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17487                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17488                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17489                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17490                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17491                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17492                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17493                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17494                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17495                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17496                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17497                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17498                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17499         }
17500         ndr_print_enum(ndr, name, "ENUM", val, r);
17501 }
17502
17503 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17504 {
17505         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17506         return NDR_ERR_SUCCESS;
17507 }
17508
17509 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17510 {
17511         uint32_t v;
17512         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17513         *r = v;
17514         return NDR_ERR_SUCCESS;
17515 }
17516
17517 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17518 {
17519         const char *val = NULL;
17520
17521         switch (r) {
17522                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17523                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17524                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17525         }
17526         ndr_print_enum(ndr, name, "ENUM", val, r);
17527 }
17528
17529 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17530 {
17531         if (ndr_flags & NDR_SCALARS) {
17532                 NDR_CHECK(ndr_push_align(ndr, 5));
17533                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17534                 {
17535                         uint32_t _flags_save_string = ndr->flags;
17536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17538                         ndr->flags = _flags_save_string;
17539                 }
17540                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17541                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17542         }
17543         if (ndr_flags & NDR_BUFFERS) {
17544                 {
17545                         uint32_t _flags_save_string = ndr->flags;
17546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17547                         if (r->status_string) {
17548                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->status_string));
17549                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17550                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->status_string));
17551                         }
17552                         ndr->flags = _flags_save_string;
17553                 }
17554         }
17555         return NDR_ERR_SUCCESS;
17556 }
17557
17558 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17559 {
17560         uint32_t _ptr_status_string;
17561         TALLOC_CTX *_mem_save_status_string_0;
17562         if (ndr_flags & NDR_SCALARS) {
17563                 NDR_CHECK(ndr_pull_align(ndr, 5));
17564                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17565                 {
17566                         uint32_t _flags_save_string = ndr->flags;
17567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17568                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17569                         if (_ptr_status_string) {
17570                                 NDR_PULL_ALLOC(ndr, r->status_string);
17571                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17572                         } else {
17573                                 r->status_string = NULL;
17574                         }
17575                         ndr->flags = _flags_save_string;
17576                 }
17577                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17578                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17579         }
17580         if (ndr_flags & NDR_BUFFERS) {
17581                 {
17582                         uint32_t _flags_save_string = ndr->flags;
17583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17584                         if (r->status_string) {
17585                                 uint32_t _relative_save_offset;
17586                                 _relative_save_offset = ndr->offset;
17587                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17588                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17589                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17590                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17591                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17592                                 ndr->offset = _relative_save_offset;
17593                         }
17594                         ndr->flags = _flags_save_string;
17595                 }
17596         }
17597         return NDR_ERR_SUCCESS;
17598 }
17599
17600 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17601 {
17602         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17603         ndr->depth++;
17604         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17605         ndr_print_ptr(ndr, "status_string", r->status_string);
17606         ndr->depth++;
17607         if (r->status_string) {
17608                 ndr_print_string(ndr, "status_string", r->status_string);
17609         }
17610         ndr->depth--;
17611         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17612         ndr->depth--;
17613 }
17614
17615 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17616 {
17617         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17618 }
17619
17620 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17621 {
17622         if (ndr_flags & NDR_SCALARS) {
17623                 NDR_CHECK(ndr_push_align(ndr, 5));
17624                 {
17625                         uint32_t _flags_save_string = ndr->flags;
17626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17627                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17628                         ndr->flags = _flags_save_string;
17629                 }
17630                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17631                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17632         }
17633         if (ndr_flags & NDR_BUFFERS) {
17634                 {
17635                         uint32_t _flags_save_string = ndr->flags;
17636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17637                         if (r->port_name) {
17638                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17639                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17640                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17641                         }
17642                         ndr->flags = _flags_save_string;
17643                 }
17644         }
17645         return NDR_ERR_SUCCESS;
17646 }
17647
17648 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17649 {
17650         uint32_t _ptr_port_name;
17651         TALLOC_CTX *_mem_save_port_name_0;
17652         if (ndr_flags & NDR_SCALARS) {
17653                 NDR_CHECK(ndr_pull_align(ndr, 5));
17654                 {
17655                         uint32_t _flags_save_string = ndr->flags;
17656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17657                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17658                         if (_ptr_port_name) {
17659                                 NDR_PULL_ALLOC(ndr, r->port_name);
17660                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17661                         } else {
17662                                 r->port_name = NULL;
17663                         }
17664                         ndr->flags = _flags_save_string;
17665                 }
17666                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17667                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17668         }
17669         if (ndr_flags & NDR_BUFFERS) {
17670                 {
17671                         uint32_t _flags_save_string = ndr->flags;
17672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17673                         if (r->port_name) {
17674                                 uint32_t _relative_save_offset;
17675                                 _relative_save_offset = ndr->offset;
17676                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17677                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17678                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17679                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17680                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17681                                 ndr->offset = _relative_save_offset;
17682                         }
17683                         ndr->flags = _flags_save_string;
17684                 }
17685         }
17686         return NDR_ERR_SUCCESS;
17687 }
17688
17689 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17690 {
17691         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17692         ndr->depth++;
17693         ndr_print_ptr(ndr, "port_name", r->port_name);
17694         ndr->depth++;
17695         if (r->port_name) {
17696                 ndr_print_string(ndr, "port_name", r->port_name);
17697         }
17698         ndr->depth--;
17699         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17700         ndr->depth--;
17701 }
17702
17703 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17704 {
17705         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17706 }
17707
17708 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17709 {
17710         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17711         {
17712                 uint32_t _flags_save_UNION = ndr->flags;
17713                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17714                 if (ndr_flags & NDR_SCALARS) {
17715                         int level = ndr_push_get_switch_value(ndr, r);
17716                         NDR_CHECK(ndr_push_union_align(ndr, 5));
17717                         switch (level) {
17718                                 case 1: {
17719                                         NDR_CHECK(ndr_push_align(ndr, 5));
17720                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17721                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17722                                 break; }
17723
17724                                 case 2: {
17725                                         NDR_CHECK(ndr_push_align(ndr, 5));
17726                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17727                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17728                                 break; }
17729
17730                                 case 3: {
17731                                         NDR_CHECK(ndr_push_align(ndr, 5));
17732                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17733                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17734                                 break; }
17735
17736                                 case 0xff: {
17737                                         NDR_CHECK(ndr_push_align(ndr, 5));
17738                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17739                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17740                                 break; }
17741
17742                                 default: {
17743                                 break; }
17744
17745                         }
17746                 }
17747                 if (ndr_flags & NDR_BUFFERS) {
17748                         int level = ndr_push_get_switch_value(ndr, r);
17749                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17750                         switch (level) {
17751                                 case 1:
17752                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17753                                 break;
17754
17755                                 case 2:
17756                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17757                                 break;
17758
17759                                 case 3:
17760                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17761                                 break;
17762
17763                                 case 0xff:
17764                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17765                                 break;
17766
17767                                 default:
17768                                 break;
17769
17770                         }
17771                 }
17772                 ndr->flags = _flags_save_UNION;
17773         }
17774         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17775         return NDR_ERR_SUCCESS;
17776 }
17777
17778 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17779 {
17780         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17781         int level;
17782         {
17783                 uint32_t _flags_save_UNION = ndr->flags;
17784                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17785                 level = ndr_pull_get_switch_value(ndr, r);
17786                 if (ndr_flags & NDR_SCALARS) {
17787                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
17788                         switch (level) {
17789                                 case 1: {
17790                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17791                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17792                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17793                                 break; }
17794
17795                                 case 2: {
17796                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17797                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17798                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17799                                 break; }
17800
17801                                 case 3: {
17802                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17803                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17804                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17805                                 break; }
17806
17807                                 case 0xff: {
17808                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17809                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17810                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17811                                 break; }
17812
17813                                 default: {
17814                                 break; }
17815
17816                         }
17817                 }
17818                 if (ndr_flags & NDR_BUFFERS) {
17819                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17820                         switch (level) {
17821                                 case 1:
17822                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17823                                 break;
17824
17825                                 case 2:
17826                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17827                                 break;
17828
17829                                 case 3:
17830                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17831                                 break;
17832
17833                                 case 0xff:
17834                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17835                                 break;
17836
17837                                 default:
17838                                 break;
17839
17840                         }
17841                 }
17842                 ndr->flags = _flags_save_UNION;
17843         }
17844         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17845         return NDR_ERR_SUCCESS;
17846 }
17847
17848 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17849 {
17850         int level;
17851         {
17852                 uint32_t _flags_save_UNION = ndr->flags;
17853                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17854                 level = ndr_print_get_switch_value(ndr, r);
17855                 ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17856                 switch (level) {
17857                         case 1:
17858                                 ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17859                         break;
17860
17861                         case 2:
17862                                 ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17863                         break;
17864
17865                         case 3:
17866                                 ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17867                         break;
17868
17869                         case 0xff:
17870                                 ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17871                         break;
17872
17873                         default:
17874                         break;
17875
17876                 }
17877                 ndr->flags = _flags_save_UNION;
17878         }
17879 }
17880
17881 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17882 {
17883         if (ndr_flags & NDR_SCALARS) {
17884                 NDR_CHECK(ndr_push_align(ndr, 5));
17885                 {
17886                         uint32_t _flags_save_string = ndr->flags;
17887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17888                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17889                         ndr->flags = _flags_save_string;
17890                 }
17891                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17892         }
17893         if (ndr_flags & NDR_BUFFERS) {
17894                 {
17895                         uint32_t _flags_save_string = ndr->flags;
17896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17897                         if (r->monitor_name) {
17898                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17899                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17900                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17901                         }
17902                         ndr->flags = _flags_save_string;
17903                 }
17904         }
17905         return NDR_ERR_SUCCESS;
17906 }
17907
17908 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17909 {
17910         uint32_t _ptr_monitor_name;
17911         TALLOC_CTX *_mem_save_monitor_name_0;
17912         if (ndr_flags & NDR_SCALARS) {
17913                 NDR_CHECK(ndr_pull_align(ndr, 5));
17914                 {
17915                         uint32_t _flags_save_string = ndr->flags;
17916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17917                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17918                         if (_ptr_monitor_name) {
17919                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17920                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17921                         } else {
17922                                 r->monitor_name = NULL;
17923                         }
17924                         ndr->flags = _flags_save_string;
17925                 }
17926                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17927         }
17928         if (ndr_flags & NDR_BUFFERS) {
17929                 {
17930                         uint32_t _flags_save_string = ndr->flags;
17931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17932                         if (r->monitor_name) {
17933                                 uint32_t _relative_save_offset;
17934                                 _relative_save_offset = ndr->offset;
17935                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17936                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17937                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17938                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17939                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17940                                 ndr->offset = _relative_save_offset;
17941                         }
17942                         ndr->flags = _flags_save_string;
17943                 }
17944         }
17945         return NDR_ERR_SUCCESS;
17946 }
17947
17948 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17949 {
17950         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17951         ndr->depth++;
17952         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17953         ndr->depth++;
17954         if (r->monitor_name) {
17955                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17956         }
17957         ndr->depth--;
17958         ndr->depth--;
17959 }
17960
17961 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17962 {
17963         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17964 }
17965
17966 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17967 {
17968         if (ndr_flags & NDR_SCALARS) {
17969                 NDR_CHECK(ndr_push_align(ndr, 5));
17970                 {
17971                         uint32_t _flags_save_string = ndr->flags;
17972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17973                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17974                         ndr->flags = _flags_save_string;
17975                 }
17976                 {
17977                         uint32_t _flags_save_string = ndr->flags;
17978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17979                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17980                         ndr->flags = _flags_save_string;
17981                 }
17982                 {
17983                         uint32_t _flags_save_string = ndr->flags;
17984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17985                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17986                         ndr->flags = _flags_save_string;
17987                 }
17988                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17989         }
17990         if (ndr_flags & NDR_BUFFERS) {
17991                 {
17992                         uint32_t _flags_save_string = ndr->flags;
17993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17994                         if (r->monitor_name) {
17995                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17996                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17997                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17998                         }
17999                         ndr->flags = _flags_save_string;
18000                 }
18001                 {
18002                         uint32_t _flags_save_string = ndr->flags;
18003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18004                         if (r->environment) {
18005                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->environment));
18006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
18007                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->environment));
18008                         }
18009                         ndr->flags = _flags_save_string;
18010                 }
18011                 {
18012                         uint32_t _flags_save_string = ndr->flags;
18013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18014                         if (r->dll_name) {
18015                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dll_name));
18016                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18017                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dll_name));
18018                         }
18019                         ndr->flags = _flags_save_string;
18020                 }
18021         }
18022         return NDR_ERR_SUCCESS;
18023 }
18024
18025 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
18026 {
18027         uint32_t _ptr_monitor_name;
18028         TALLOC_CTX *_mem_save_monitor_name_0;
18029         uint32_t _ptr_environment;
18030         TALLOC_CTX *_mem_save_environment_0;
18031         uint32_t _ptr_dll_name;
18032         TALLOC_CTX *_mem_save_dll_name_0;
18033         if (ndr_flags & NDR_SCALARS) {
18034                 NDR_CHECK(ndr_pull_align(ndr, 5));
18035                 {
18036                         uint32_t _flags_save_string = ndr->flags;
18037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18038                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
18039                         if (_ptr_monitor_name) {
18040                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
18041                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
18042                         } else {
18043                                 r->monitor_name = NULL;
18044                         }
18045                         ndr->flags = _flags_save_string;
18046                 }
18047                 {
18048                         uint32_t _flags_save_string = ndr->flags;
18049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18050                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
18051                         if (_ptr_environment) {
18052                                 NDR_PULL_ALLOC(ndr, r->environment);
18053                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
18054                         } else {
18055                                 r->environment = NULL;
18056                         }
18057                         ndr->flags = _flags_save_string;
18058                 }
18059                 {
18060                         uint32_t _flags_save_string = ndr->flags;
18061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18062                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
18063                         if (_ptr_dll_name) {
18064                                 NDR_PULL_ALLOC(ndr, r->dll_name);
18065                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
18066                         } else {
18067                                 r->dll_name = NULL;
18068                         }
18069                         ndr->flags = _flags_save_string;
18070                 }
18071                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18072         }
18073         if (ndr_flags & NDR_BUFFERS) {
18074                 {
18075                         uint32_t _flags_save_string = ndr->flags;
18076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18077                         if (r->monitor_name) {
18078                                 uint32_t _relative_save_offset;
18079                                 _relative_save_offset = ndr->offset;
18080                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
18081                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18082                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
18083                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
18084                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
18085                                 ndr->offset = _relative_save_offset;
18086                         }
18087                         ndr->flags = _flags_save_string;
18088                 }
18089                 {
18090                         uint32_t _flags_save_string = ndr->flags;
18091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18092                         if (r->environment) {
18093                                 uint32_t _relative_save_offset;
18094                                 _relative_save_offset = ndr->offset;
18095                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
18096                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18097                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
18098                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
18099                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18100                                 ndr->offset = _relative_save_offset;
18101                         }
18102                         ndr->flags = _flags_save_string;
18103                 }
18104                 {
18105                         uint32_t _flags_save_string = ndr->flags;
18106                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18107                         if (r->dll_name) {
18108                                 uint32_t _relative_save_offset;
18109                                 _relative_save_offset = ndr->offset;
18110                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
18111                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18112                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
18113                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18114                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
18115                                 ndr->offset = _relative_save_offset;
18116                         }
18117                         ndr->flags = _flags_save_string;
18118                 }
18119         }
18120         return NDR_ERR_SUCCESS;
18121 }
18122
18123 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
18124 {
18125         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
18126         ndr->depth++;
18127         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
18128         ndr->depth++;
18129         if (r->monitor_name) {
18130                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
18131         }
18132         ndr->depth--;
18133         ndr_print_ptr(ndr, "environment", r->environment);
18134         ndr->depth++;
18135         if (r->environment) {
18136                 ndr_print_string(ndr, "environment", r->environment);
18137         }
18138         ndr->depth--;
18139         ndr_print_ptr(ndr, "dll_name", r->dll_name);
18140         ndr->depth++;
18141         if (r->dll_name) {
18142                 ndr_print_string(ndr, "dll_name", r->dll_name);
18143         }
18144         ndr->depth--;
18145         ndr->depth--;
18146 }
18147
18148 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
18149 {
18150         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
18151 }
18152
18153 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
18154 {
18155         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18156         {
18157                 uint32_t _flags_save_UNION = ndr->flags;
18158                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18159                 if (ndr_flags & NDR_SCALARS) {
18160                         int level = ndr_push_get_switch_value(ndr, r);
18161                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18162                         switch (level) {
18163                                 case 1: {
18164                                         NDR_CHECK(ndr_push_align(ndr, 5));
18165                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18166                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18167                                 break; }
18168
18169                                 case 2: {
18170                                         NDR_CHECK(ndr_push_align(ndr, 5));
18171                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18172                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18173                                 break; }
18174
18175                                 default: {
18176                                 break; }
18177
18178                         }
18179                 }
18180                 if (ndr_flags & NDR_BUFFERS) {
18181                         int level = ndr_push_get_switch_value(ndr, r);
18182                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18183                         switch (level) {
18184                                 case 1:
18185                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18186                                 break;
18187
18188                                 case 2:
18189                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18190                                 break;
18191
18192                                 default:
18193                                 break;
18194
18195                         }
18196                 }
18197                 ndr->flags = _flags_save_UNION;
18198         }
18199         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18200         return NDR_ERR_SUCCESS;
18201 }
18202
18203 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
18204 {
18205         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18206         int level;
18207         {
18208                 uint32_t _flags_save_UNION = ndr->flags;
18209                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18210                 level = ndr_pull_get_switch_value(ndr, r);
18211                 if (ndr_flags & NDR_SCALARS) {
18212                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18213                         switch (level) {
18214                                 case 1: {
18215                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18216                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18217                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18218                                 break; }
18219
18220                                 case 2: {
18221                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18222                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18223                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18224                                 break; }
18225
18226                                 default: {
18227                                 break; }
18228
18229                         }
18230                 }
18231                 if (ndr_flags & NDR_BUFFERS) {
18232                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18233                         switch (level) {
18234                                 case 1:
18235                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18236                                 break;
18237
18238                                 case 2:
18239                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18240                                 break;
18241
18242                                 default:
18243                                 break;
18244
18245                         }
18246                 }
18247                 ndr->flags = _flags_save_UNION;
18248         }
18249         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18250         return NDR_ERR_SUCCESS;
18251 }
18252
18253 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
18254 {
18255         int level;
18256         {
18257                 uint32_t _flags_save_UNION = ndr->flags;
18258                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18259                 level = ndr_print_get_switch_value(ndr, r);
18260                 ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
18261                 switch (level) {
18262                         case 1:
18263                                 ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
18264                         break;
18265
18266                         case 2:
18267                                 ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
18268                         break;
18269
18270                         default:
18271                         break;
18272
18273                 }
18274                 ndr->flags = _flags_save_UNION;
18275         }
18276 }
18277
18278 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
18279 {
18280         if (ndr_flags & NDR_SCALARS) {
18281                 NDR_CHECK(ndr_push_align(ndr, 5));
18282                 {
18283                         uint32_t _flags_save_string = ndr->flags;
18284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18285                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
18286                         ndr->flags = _flags_save_string;
18287                 }
18288                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18289         }
18290         if (ndr_flags & NDR_BUFFERS) {
18291                 {
18292                         uint32_t _flags_save_string = ndr->flags;
18293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18294                         if (r->name_array) {
18295                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name_array));
18296                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
18297                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name_array));
18298                         }
18299                         ndr->flags = _flags_save_string;
18300                 }
18301         }
18302         return NDR_ERR_SUCCESS;
18303 }
18304
18305 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
18306 {
18307         uint32_t _ptr_name_array;
18308         TALLOC_CTX *_mem_save_name_array_0;
18309         if (ndr_flags & NDR_SCALARS) {
18310                 NDR_CHECK(ndr_pull_align(ndr, 5));
18311                 {
18312                         uint32_t _flags_save_string = ndr->flags;
18313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18314                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
18315                         if (_ptr_name_array) {
18316                                 NDR_PULL_ALLOC(ndr, r->name_array);
18317                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
18318                         } else {
18319                                 r->name_array = NULL;
18320                         }
18321                         ndr->flags = _flags_save_string;
18322                 }
18323                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18324         }
18325         if (ndr_flags & NDR_BUFFERS) {
18326                 {
18327                         uint32_t _flags_save_string = ndr->flags;
18328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
18329                         if (r->name_array) {
18330                                 uint32_t _relative_save_offset;
18331                                 _relative_save_offset = ndr->offset;
18332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
18333                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
18334                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
18335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
18336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
18337                                 ndr->offset = _relative_save_offset;
18338                         }
18339                         ndr->flags = _flags_save_string;
18340                 }
18341         }
18342         return NDR_ERR_SUCCESS;
18343 }
18344
18345 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
18346 {
18347         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
18348         ndr->depth++;
18349         ndr_print_ptr(ndr, "name_array", r->name_array);
18350         ndr->depth++;
18351         if (r->name_array) {
18352                 ndr_print_string(ndr, "name_array", r->name_array);
18353         }
18354         ndr->depth--;
18355         ndr->depth--;
18356 }
18357
18358 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18359 {
18360         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
18361 }
18362
18363 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
18364 {
18365         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18366         {
18367                 uint32_t _flags_save_UNION = ndr->flags;
18368                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18369                 if (ndr_flags & NDR_SCALARS) {
18370                         int level = ndr_push_get_switch_value(ndr, r);
18371                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18372                         switch (level) {
18373                                 case 1: {
18374                                         NDR_CHECK(ndr_push_align(ndr, 5));
18375                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18376                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18377                                 break; }
18378
18379                                 default: {
18380                                 break; }
18381
18382                         }
18383                 }
18384                 if (ndr_flags & NDR_BUFFERS) {
18385                         int level = ndr_push_get_switch_value(ndr, r);
18386                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18387                         switch (level) {
18388                                 case 1:
18389                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18390                                 break;
18391
18392                                 default:
18393                                 break;
18394
18395                         }
18396                 }
18397                 ndr->flags = _flags_save_UNION;
18398         }
18399         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18400         return NDR_ERR_SUCCESS;
18401 }
18402
18403 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
18404 {
18405         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18406         int level;
18407         {
18408                 uint32_t _flags_save_UNION = ndr->flags;
18409                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18410                 level = ndr_pull_get_switch_value(ndr, r);
18411                 if (ndr_flags & NDR_SCALARS) {
18412                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18413                         switch (level) {
18414                                 case 1: {
18415                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18416                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18417                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18418                                 break; }
18419
18420                                 default: {
18421                                 break; }
18422
18423                         }
18424                 }
18425                 if (ndr_flags & NDR_BUFFERS) {
18426                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18427                         switch (level) {
18428                                 case 1:
18429                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18430                                 break;
18431
18432                                 default:
18433                                 break;
18434
18435                         }
18436                 }
18437                 ndr->flags = _flags_save_UNION;
18438         }
18439         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18440         return NDR_ERR_SUCCESS;
18441 }
18442
18443 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
18444 {
18445         int level;
18446         {
18447                 uint32_t _flags_save_UNION = ndr->flags;
18448                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18449                 level = ndr_print_get_switch_value(ndr, r);
18450                 ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
18451                 switch (level) {
18452                         case 1:
18453                                 ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
18454                         break;
18455
18456                         default:
18457                         break;
18458
18459                 }
18460                 ndr->flags = _flags_save_UNION;
18461         }
18462 }
18463
18464 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18465 {
18466         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18467         return NDR_ERR_SUCCESS;
18468 }
18469
18470 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18471 {
18472         uint32_t v;
18473         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18474         *r = v;
18475         return NDR_ERR_SUCCESS;
18476 }
18477
18478 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18479 {
18480         ndr_print_uint32(ndr, name, r);
18481         ndr->depth++;
18482         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18483         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18484         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18485         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18486         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18487         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18488         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18489         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18490         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18491         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18492         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18493         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18494         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18495         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18496         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18497         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18498         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18499         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18500         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18501         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18502         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18503         ndr->depth--;
18504 }
18505
18506 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18507 {
18508         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18509         return NDR_ERR_SUCCESS;
18510 }
18511
18512 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18513 {
18514         uint16_t v;
18515         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18516         *r = v;
18517         return NDR_ERR_SUCCESS;
18518 }
18519
18520 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18521 {
18522         const char *val = NULL;
18523
18524         switch (r) {
18525                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18526                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18527                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18528                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18529                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18530                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18531                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18532                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18533                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18534                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18535                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18536                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18537                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18538                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18539                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18540                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18541                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18542                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18543                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18544                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18545                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18546                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18547                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18548                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18549         }
18550         ndr_print_enum(ndr, name, "ENUM", val, r);
18551 }
18552
18553 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18554 {
18555         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18556         return NDR_ERR_SUCCESS;
18557 }
18558
18559 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18560 {
18561         uint16_t v;
18562         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18563         *r = v;
18564         return NDR_ERR_SUCCESS;
18565 }
18566
18567 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18568 {
18569         const char *val = NULL;
18570
18571         switch (r) {
18572                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18573                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18574                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18575                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18576                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18577                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18578                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18579                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18580                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18581                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18582                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18583                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18584                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18585                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18586                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18587                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18588                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18589                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18590                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18591                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18592                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18593                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18594                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18595                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18596                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18597                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18598                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18599                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18600         }
18601         ndr_print_enum(ndr, name, "ENUM", val, r);
18602 }
18603
18604 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18605 {
18606         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18607         return NDR_ERR_SUCCESS;
18608 }
18609
18610 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18611 {
18612         uint16_t v;
18613         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18614         *r = v;
18615         return NDR_ERR_SUCCESS;
18616 }
18617
18618 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18619 {
18620         const char *val = NULL;
18621
18622         switch (r) {
18623                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18624                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18625         }
18626         ndr_print_enum(ndr, name, "ENUM", val, r);
18627 }
18628
18629 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18630 {
18631         if (ndr_flags & NDR_SCALARS) {
18632                 int level = ndr_push_get_switch_value(ndr, r);
18633                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18634                 switch (level) {
18635                         case PRINTER_NOTIFY_TYPE: {
18636                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18637                         break; }
18638
18639                         case JOB_NOTIFY_TYPE: {
18640                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18641                         break; }
18642
18643                         default: {
18644                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18645                         break; }
18646
18647                 }
18648         }
18649         if (ndr_flags & NDR_BUFFERS) {
18650                 int level = ndr_push_get_switch_value(ndr, r);
18651                 switch (level) {
18652                         case PRINTER_NOTIFY_TYPE:
18653                         break;
18654
18655                         case JOB_NOTIFY_TYPE:
18656                         break;
18657
18658                         default:
18659                         break;
18660
18661                 }
18662         }
18663         return NDR_ERR_SUCCESS;
18664 }
18665
18666 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18667 {
18668         int level;
18669         level = ndr_pull_get_switch_value(ndr, r);
18670         if (ndr_flags & NDR_SCALARS) {
18671                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18672                 switch (level) {
18673                         case PRINTER_NOTIFY_TYPE: {
18674                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18675                         break; }
18676
18677                         case JOB_NOTIFY_TYPE: {
18678                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18679                         break; }
18680
18681                         default: {
18682                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18683                         break; }
18684
18685                 }
18686         }
18687         if (ndr_flags & NDR_BUFFERS) {
18688                 switch (level) {
18689                         case PRINTER_NOTIFY_TYPE:
18690                         break;
18691
18692                         case JOB_NOTIFY_TYPE:
18693                         break;
18694
18695                         default:
18696                         break;
18697
18698                 }
18699         }
18700         return NDR_ERR_SUCCESS;
18701 }
18702
18703 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18704 {
18705         uint32_t cntr_fields_1;
18706         if (ndr_flags & NDR_SCALARS) {
18707                 NDR_CHECK(ndr_push_align(ndr, 5));
18708                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18709                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18714                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18715         }
18716         if (ndr_flags & NDR_BUFFERS) {
18717                 if (r->fields) {
18718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18719                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18720                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18721                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18722                         }
18723                 }
18724         }
18725         return NDR_ERR_SUCCESS;
18726 }
18727
18728 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18729 {
18730         uint32_t _ptr_fields;
18731         uint32_t size_fields_1 = 0;
18732         uint32_t cntr_fields_1;
18733         TALLOC_CTX *_mem_save_fields_0;
18734         TALLOC_CTX *_mem_save_fields_1;
18735         if (ndr_flags & NDR_SCALARS) {
18736                 NDR_CHECK(ndr_pull_align(ndr, 5));
18737                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18738                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18742                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18743                 if (_ptr_fields) {
18744                         NDR_PULL_ALLOC(ndr, r->fields);
18745                 } else {
18746                         r->fields = NULL;
18747                 }
18748                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18749         }
18750         if (ndr_flags & NDR_BUFFERS) {
18751                 if (r->fields) {
18752                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18753                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18754                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18755                         size_fields_1 = ndr_get_array_size(ndr, &r->fields);
18756                         NDR_PULL_ALLOC_N(ndr, r->fields, size_fields_1);
18757                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18758                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18759                         for (cntr_fields_1 = 0; cntr_fields_1 < size_fields_1; cntr_fields_1++) {
18760                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18761                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18762                         }
18763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18764                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18765                 }
18766                 if (r->fields) {
18767                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18768                 }
18769         }
18770         return NDR_ERR_SUCCESS;
18771 }
18772
18773 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18774 {
18775         uint32_t cntr_fields_1;
18776         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18777         ndr->depth++;
18778         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18779         ndr_print_uint16(ndr, "u1", r->u1);
18780         ndr_print_uint32(ndr, "u2", r->u2);
18781         ndr_print_uint32(ndr, "u3", r->u3);
18782         ndr_print_uint32(ndr, "count", r->count);
18783         ndr_print_ptr(ndr, "fields", r->fields);
18784         ndr->depth++;
18785         if (r->fields) {
18786                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18787                 ndr->depth++;
18788                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18789                         char *idx_1=NULL;
18790                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18791                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18792                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18793                                 free(idx_1);
18794                         }
18795                 }
18796                 ndr->depth--;
18797         }
18798         ndr->depth--;
18799         ndr->depth--;
18800 }
18801
18802 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18803 {
18804         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18805         return NDR_ERR_SUCCESS;
18806 }
18807
18808 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18809 {
18810         uint32_t v;
18811         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18812         *r = v;
18813         return NDR_ERR_SUCCESS;
18814 }
18815
18816 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18817 {
18818         ndr_print_uint32(ndr, name, r);
18819         ndr->depth++;
18820         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18821         ndr->depth--;
18822 }
18823
18824 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18825 {
18826         uint32_t cntr_types_1;
18827         if (ndr_flags & NDR_SCALARS) {
18828                 NDR_CHECK(ndr_push_align(ndr, 5));
18829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18830                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18833                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18834         }
18835         if (ndr_flags & NDR_BUFFERS) {
18836                 if (r->types) {
18837                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18838                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18839                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18840                         }
18841                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18842                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18843                         }
18844                 }
18845         }
18846         return NDR_ERR_SUCCESS;
18847 }
18848
18849 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18850 {
18851         uint32_t _ptr_types;
18852         uint32_t size_types_1 = 0;
18853         uint32_t cntr_types_1;
18854         TALLOC_CTX *_mem_save_types_0;
18855         TALLOC_CTX *_mem_save_types_1;
18856         if (ndr_flags & NDR_SCALARS) {
18857                 NDR_CHECK(ndr_pull_align(ndr, 5));
18858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18859                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18862                 if (_ptr_types) {
18863                         NDR_PULL_ALLOC(ndr, r->types);
18864                 } else {
18865                         r->types = NULL;
18866                 }
18867                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18868         }
18869         if (ndr_flags & NDR_BUFFERS) {
18870                 if (r->types) {
18871                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18872                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18874                         size_types_1 = ndr_get_array_size(ndr, &r->types);
18875                         NDR_PULL_ALLOC_N(ndr, r->types, size_types_1);
18876                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18877                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18878                         for (cntr_types_1 = 0; cntr_types_1 < size_types_1; cntr_types_1++) {
18879                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18880                         }
18881                         for (cntr_types_1 = 0; cntr_types_1 < size_types_1; cntr_types_1++) {
18882                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18883                         }
18884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18886                 }
18887                 if (r->types) {
18888                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18889                 }
18890         }
18891         return NDR_ERR_SUCCESS;
18892 }
18893
18894 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18895 {
18896         uint32_t cntr_types_1;
18897         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18898         ndr->depth++;
18899         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18900         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18901         ndr_print_uint32(ndr, "count", r->count);
18902         ndr_print_ptr(ndr, "types", r->types);
18903         ndr->depth++;
18904         if (r->types) {
18905                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18906                 ndr->depth++;
18907                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18908                         char *idx_1=NULL;
18909                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18910                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18911                                 free(idx_1);
18912                         }
18913                 }
18914                 ndr->depth--;
18915         }
18916         ndr->depth--;
18917         ndr->depth--;
18918 }
18919
18920 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18921 {
18922         if (ndr_flags & NDR_SCALARS) {
18923                 NDR_CHECK(ndr_push_align(ndr, 5));
18924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18925                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18926                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18927         }
18928         if (ndr_flags & NDR_BUFFERS) {
18929                 if (r->string) {
18930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18931                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18932                 }
18933         }
18934         return NDR_ERR_SUCCESS;
18935 }
18936
18937 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18938 {
18939         uint32_t _ptr_string;
18940         uint32_t size_string_1 = 0;
18941         TALLOC_CTX *_mem_save_string_0;
18942         if (ndr_flags & NDR_SCALARS) {
18943                 NDR_CHECK(ndr_pull_align(ndr, 5));
18944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18945                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18946                 if (_ptr_string) {
18947                         NDR_PULL_ALLOC(ndr, r->string);
18948                 } else {
18949                         r->string = NULL;
18950                 }
18951                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18952         }
18953         if (ndr_flags & NDR_BUFFERS) {
18954                 if (r->string) {
18955                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18956                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18958                         size_string_1 = ndr_get_array_size(ndr, &r->string);
18959                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, size_string_1, sizeof(uint16_t), CH_UTF16));
18960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18961                 }
18962                 if (r->string) {
18963                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18964                 }
18965         }
18966         return NDR_ERR_SUCCESS;
18967 }
18968
18969 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18970 {
18971         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18972         ndr->depth++;
18973         ndr_print_uint32(ndr, "size", r->size);
18974         ndr_print_ptr(ndr, "string", r->string);
18975         ndr->depth++;
18976         if (r->string) {
18977                 ndr_print_string(ndr, "string", r->string);
18978         }
18979         ndr->depth--;
18980         ndr->depth--;
18981 }
18982
18983 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18984 {
18985         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18986         return NDR_ERR_SUCCESS;
18987 }
18988
18989 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18990 {
18991         uint32_t v;
18992         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18993         *r = v;
18994         return NDR_ERR_SUCCESS;
18995 }
18996
18997 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18998 {
18999         const char *val = NULL;
19000
19001         switch (r) {
19002                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
19003                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
19004                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
19005                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
19006                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
19007         }
19008         ndr_print_enum(ndr, name, "ENUM", val, r);
19009 }
19010
19011 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
19012 {
19013         if (ndr_flags & NDR_SCALARS) {
19014                 int level = ndr_push_get_switch_value(ndr, r);
19015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19016                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19017                 switch (level) {
19018                         case 1: {
19019                                 uint32_t cntr_integer_0;
19020                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
19021                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
19022                                 }
19023                         break; }
19024
19025                         case 2: {
19026                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
19027                         break; }
19028
19029                         case 3: {
19030                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
19031                         break; }
19032
19033                         case 4: {
19034                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
19035                         break; }
19036
19037                         case 5: {
19038                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
19039                         break; }
19040
19041                         default:
19042                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19043                 }
19044         }
19045         if (ndr_flags & NDR_BUFFERS) {
19046                 int level = ndr_push_get_switch_value(ndr, r);
19047                 switch (level) {
19048                         case 1:
19049                         break;
19050
19051                         case 2:
19052                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19053                         break;
19054
19055                         case 3:
19056                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19057                         break;
19058
19059                         case 4:
19060                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19061                         break;
19062
19063                         case 5:
19064                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19065                         break;
19066
19067                         default:
19068                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19069                 }
19070         }
19071         return NDR_ERR_SUCCESS;
19072 }
19073
19074 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
19075 {
19076         int level;
19077         uint32_t _level;
19078         uint32_t size_integer_0 = 0;
19079         uint32_t cntr_integer_0;
19080         level = ndr_pull_get_switch_value(ndr, r);
19081         if (ndr_flags & NDR_SCALARS) {
19082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19083                 if (_level != level) {
19084                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19085                 }
19086                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19087                 switch (level) {
19088                         case 1: {
19089                                 size_integer_0 = 2;
19090                                 for (cntr_integer_0 = 0; cntr_integer_0 < size_integer_0; cntr_integer_0++) {
19091                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
19092                                 }
19093                         break; }
19094
19095                         case 2: {
19096                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
19097                         break; }
19098
19099                         case 3: {
19100                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
19101                         break; }
19102
19103                         case 4: {
19104                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
19105                         break; }
19106
19107                         case 5: {
19108                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
19109                         break; }
19110
19111                         default:
19112                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19113                 }
19114         }
19115         if (ndr_flags & NDR_BUFFERS) {
19116                 switch (level) {
19117                         case 1:
19118                         break;
19119
19120                         case 2:
19121                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19122                         break;
19123
19124                         case 3:
19125                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19126                         break;
19127
19128                         case 4:
19129                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19130                         break;
19131
19132                         case 5:
19133                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19134                         break;
19135
19136                         default:
19137                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19138                 }
19139         }
19140         return NDR_ERR_SUCCESS;
19141 }
19142
19143 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
19144 {
19145         int level;
19146         uint32_t cntr_integer_0;
19147         level = ndr_print_get_switch_value(ndr, r);
19148         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
19149         switch (level) {
19150                 case 1:
19151                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
19152                         ndr->depth++;
19153                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
19154                                 char *idx_0=NULL;
19155                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
19156                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
19157                                         free(idx_0);
19158                                 }
19159                         }
19160                         ndr->depth--;
19161                 break;
19162
19163                 case 2:
19164                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
19165                 break;
19166
19167                 case 3:
19168                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
19169                 break;
19170
19171                 case 4:
19172                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
19173                 break;
19174
19175                 case 5:
19176                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
19177                 break;
19178
19179                 default:
19180                         ndr_print_bad_level(ndr, name, level);
19181         }
19182 }
19183
19184 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
19185 {
19186         if (ndr_flags & NDR_SCALARS) {
19187                 NDR_CHECK(ndr_push_align(ndr, 5));
19188                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
19189                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
19190                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19191                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
19192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
19193                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
19194                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19195                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19196         }
19197         if (ndr_flags & NDR_BUFFERS) {
19198                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19199         }
19200         return NDR_ERR_SUCCESS;
19201 }
19202
19203 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
19204 {
19205         if (ndr_flags & NDR_SCALARS) {
19206                 NDR_CHECK(ndr_pull_align(ndr, 5));
19207                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
19208                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
19209                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19210                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
19211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
19212                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
19213                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19214                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19215         }
19216         if (ndr_flags & NDR_BUFFERS) {
19217                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19218         }
19219         return NDR_ERR_SUCCESS;
19220 }
19221
19222 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
19223 {
19224         ndr_print_struct(ndr, name, "spoolss_Notify");
19225         ndr->depth++;
19226         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
19227         ndr_print_set_switch_value(ndr, &r->field, r->type);
19228         ndr_print_spoolss_Field(ndr, "field", &r->field);
19229         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
19230         ndr_print_uint32(ndr, "job_id", r->job_id);
19231         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
19232         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
19233         ndr->depth--;
19234 }
19235
19236 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
19237 {
19238         uint32_t cntr_notifies_0;
19239         if (ndr_flags & NDR_SCALARS) {
19240                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
19241                 NDR_CHECK(ndr_push_align(ndr, 5));
19242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
19243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
19245                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19246                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19247                 }
19248                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19249         }
19250         if (ndr_flags & NDR_BUFFERS) {
19251                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19252                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19253                 }
19254         }
19255         return NDR_ERR_SUCCESS;
19256 }
19257
19258 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
19259 {
19260         uint32_t size_notifies_0 = 0;
19261         uint32_t cntr_notifies_0;
19262         TALLOC_CTX *_mem_save_notifies_0;
19263         if (ndr_flags & NDR_SCALARS) {
19264                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
19265                 NDR_CHECK(ndr_pull_align(ndr, 5));
19266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19269                 size_notifies_0 = ndr_get_array_size(ndr, &r->notifies);
19270                 NDR_PULL_ALLOC_N(ndr, r->notifies, size_notifies_0);
19271                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19272                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19273                 for (cntr_notifies_0 = 0; cntr_notifies_0 < size_notifies_0; cntr_notifies_0++) {
19274                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19275                 }
19276                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19277                 if (r->notifies) {
19278                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
19279                 }
19280                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19281         }
19282         if (ndr_flags & NDR_BUFFERS) {
19283                 size_notifies_0 = ndr_get_array_size(ndr, &r->notifies);
19284                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19285                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19286                 for (cntr_notifies_0 = 0; cntr_notifies_0 < size_notifies_0; cntr_notifies_0++) {
19287                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19288                 }
19289                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19290         }
19291         return NDR_ERR_SUCCESS;
19292 }
19293
19294 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
19295 {
19296         uint32_t cntr_notifies_0;
19297         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
19298         ndr->depth++;
19299         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19300         ndr_print_uint32(ndr, "flags", r->flags);
19301         ndr_print_uint32(ndr, "count", r->count);
19302         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
19303         ndr->depth++;
19304         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
19305                 char *idx_0=NULL;
19306                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
19307                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
19308                         free(idx_0);
19309                 }
19310         }
19311         ndr->depth--;
19312         ndr->depth--;
19313 }
19314
19315 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
19316 {
19317         if (ndr_flags & NDR_SCALARS) {
19318                 int level = ndr_push_get_switch_value(ndr, r);
19319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19320                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19321                 switch (level) {
19322                         case 0: {
19323                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
19324                         break; }
19325
19326                         default:
19327                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19328                 }
19329         }
19330         if (ndr_flags & NDR_BUFFERS) {
19331                 int level = ndr_push_get_switch_value(ndr, r);
19332                 switch (level) {
19333                         case 0:
19334                                 if (r->info0) {
19335                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19336                                 }
19337                         break;
19338
19339                         default:
19340                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19341                 }
19342         }
19343         return NDR_ERR_SUCCESS;
19344 }
19345
19346 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
19347 {
19348         int level;
19349         uint32_t _level;
19350         TALLOC_CTX *_mem_save_info0_0;
19351         uint32_t _ptr_info0;
19352         level = ndr_pull_get_switch_value(ndr, r);
19353         if (ndr_flags & NDR_SCALARS) {
19354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19355                 if (_level != level) {
19356                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19357                 }
19358                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19359                 switch (level) {
19360                         case 0: {
19361                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
19362                                 if (_ptr_info0) {
19363                                         NDR_PULL_ALLOC(ndr, r->info0);
19364                                 } else {
19365                                         r->info0 = NULL;
19366                                 }
19367                         break; }
19368
19369                         default:
19370                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19371                 }
19372         }
19373         if (ndr_flags & NDR_BUFFERS) {
19374                 switch (level) {
19375                         case 0:
19376                                 if (r->info0) {
19377                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
19378                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
19379                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19380                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
19381                                 }
19382                         break;
19383
19384                         default:
19385                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19386                 }
19387         }
19388         return NDR_ERR_SUCCESS;
19389 }
19390
19391 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
19392 {
19393         int level;
19394         level = ndr_print_get_switch_value(ndr, r);
19395         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
19396         switch (level) {
19397                 case 0:
19398                         ndr_print_ptr(ndr, "info0", r->info0);
19399                         ndr->depth++;
19400                         if (r->info0) {
19401                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
19402                         }
19403                         ndr->depth--;
19404                 break;
19405
19406                 default:
19407                         ndr_print_bad_level(ndr, name, level);
19408         }
19409 }
19410
19411 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19412 {
19413         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19414         return NDR_ERR_SUCCESS;
19415 }
19416
19417 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19418 {
19419         uint32_t v;
19420         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19421         *r = v;
19422         return NDR_ERR_SUCCESS;
19423 }
19424
19425 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19426 {
19427         ndr_print_uint32(ndr, name, r);
19428         ndr->depth++;
19429         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
19430         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
19431         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
19432         ndr->depth--;
19433 }
19434
19435 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
19436 {
19437         if (ndr_flags & NDR_SCALARS) {
19438                 NDR_CHECK(ndr_push_align(ndr, 5));
19439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19443                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19444                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19445                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19446                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19447         }
19448         if (ndr_flags & NDR_BUFFERS) {
19449                 if (r->client) {
19450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19453                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19454                 }
19455                 if (r->user) {
19456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19459                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19460                 }
19461         }
19462         return NDR_ERR_SUCCESS;
19463 }
19464
19465 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
19466 {
19467         uint32_t _ptr_client;
19468         uint32_t size_client_1 = 0;
19469         uint32_t length_client_1 = 0;
19470         TALLOC_CTX *_mem_save_client_0;
19471         uint32_t _ptr_user;
19472         uint32_t size_user_1 = 0;
19473         uint32_t length_user_1 = 0;
19474         TALLOC_CTX *_mem_save_user_0;
19475         if (ndr_flags & NDR_SCALARS) {
19476                 NDR_CHECK(ndr_pull_align(ndr, 5));
19477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19479                 if (_ptr_client) {
19480                         NDR_PULL_ALLOC(ndr, r->client);
19481                 } else {
19482                         r->client = NULL;
19483                 }
19484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19485                 if (_ptr_user) {
19486                         NDR_PULL_ALLOC(ndr, r->user);
19487                 } else {
19488                         r->user = NULL;
19489                 }
19490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19491                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19492                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19493                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19494                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19495         }
19496         if (ndr_flags & NDR_BUFFERS) {
19497                 if (r->client) {
19498                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19499                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19500                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19501                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19502                         size_client_1 = ndr_get_array_size(ndr, &r->client);
19503                         length_client_1 = ndr_get_array_length(ndr, &r->client);
19504                         if (length_client_1 > size_client_1) {
19505                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
19506                         }
19507                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
19508                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, length_client_1, sizeof(uint16_t), CH_UTF16));
19509                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19510                 }
19511                 if (r->user) {
19512                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19513                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19516                         size_user_1 = ndr_get_array_size(ndr, &r->user);
19517                         length_user_1 = ndr_get_array_length(ndr, &r->user);
19518                         if (length_user_1 > size_user_1) {
19519                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
19520                         }
19521                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
19522                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
19523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19524                 }
19525         }
19526         return NDR_ERR_SUCCESS;
19527 }
19528
19529 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19530 {
19531         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19532         ndr->depth++;
19533         ndr_print_uint32(ndr, "size", r->size);
19534         ndr_print_ptr(ndr, "client", r->client);
19535         ndr->depth++;
19536         if (r->client) {
19537                 ndr_print_string(ndr, "client", r->client);
19538         }
19539         ndr->depth--;
19540         ndr_print_ptr(ndr, "user", r->user);
19541         ndr->depth++;
19542         if (r->user) {
19543                 ndr_print_string(ndr, "user", r->user);
19544         }
19545         ndr->depth--;
19546         ndr_print_uint32(ndr, "build", r->build);
19547         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19548         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19549         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19550         ndr->depth--;
19551 }
19552
19553 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19554 {
19555         if (ndr_flags & NDR_SCALARS) {
19556                 NDR_CHECK(ndr_push_align(ndr, 4));
19557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19558                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19559         }
19560         if (ndr_flags & NDR_BUFFERS) {
19561         }
19562         return NDR_ERR_SUCCESS;
19563 }
19564
19565 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19566 {
19567         if (ndr_flags & NDR_SCALARS) {
19568                 NDR_CHECK(ndr_pull_align(ndr, 4));
19569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19570                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19571         }
19572         if (ndr_flags & NDR_BUFFERS) {
19573         }
19574         return NDR_ERR_SUCCESS;
19575 }
19576
19577 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19578 {
19579         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19580         ndr->depth++;
19581         ndr_print_uint32(ndr, "not_used", r->not_used);
19582         ndr->depth--;
19583 }
19584
19585 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19586 {
19587         if (ndr_flags & NDR_SCALARS) {
19588                 NDR_CHECK(ndr_push_align(ndr, 5));
19589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19592                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19595                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19596                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19597                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19598                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19599                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19600         }
19601         if (ndr_flags & NDR_BUFFERS) {
19602                 if (r->client) {
19603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19605                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19606                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19607                 }
19608                 if (r->user) {
19609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19612                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19613                 }
19614         }
19615         return NDR_ERR_SUCCESS;
19616 }
19617
19618 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19619 {
19620         uint32_t _ptr_client;
19621         uint32_t size_client_1 = 0;
19622         uint32_t length_client_1 = 0;
19623         TALLOC_CTX *_mem_save_client_0;
19624         uint32_t _ptr_user;
19625         uint32_t size_user_1 = 0;
19626         uint32_t length_user_1 = 0;
19627         TALLOC_CTX *_mem_save_user_0;
19628         if (ndr_flags & NDR_SCALARS) {
19629                 NDR_CHECK(ndr_pull_align(ndr, 5));
19630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19633                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19634                 if (_ptr_client) {
19635                         NDR_PULL_ALLOC(ndr, r->client);
19636                 } else {
19637                         r->client = NULL;
19638                 }
19639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19640                 if (_ptr_user) {
19641                         NDR_PULL_ALLOC(ndr, r->user);
19642                 } else {
19643                         r->user = NULL;
19644                 }
19645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19646                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19647                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19648                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19649                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19650                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19651         }
19652         if (ndr_flags & NDR_BUFFERS) {
19653                 if (r->client) {
19654                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19655                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19658                         size_client_1 = ndr_get_array_size(ndr, &r->client);
19659                         length_client_1 = ndr_get_array_length(ndr, &r->client);
19660                         if (length_client_1 > size_client_1) {
19661                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
19662                         }
19663                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
19664                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, length_client_1, sizeof(uint16_t), CH_UTF16));
19665                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19666                 }
19667                 if (r->user) {
19668                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19669                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19670                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19671                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19672                         size_user_1 = ndr_get_array_size(ndr, &r->user);
19673                         length_user_1 = ndr_get_array_length(ndr, &r->user);
19674                         if (length_user_1 > size_user_1) {
19675                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
19676                         }
19677                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
19678                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
19679                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19680                 }
19681         }
19682         return NDR_ERR_SUCCESS;
19683 }
19684
19685 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19686 {
19687         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19688         ndr->depth++;
19689         ndr_print_uint32(ndr, "size", r->size);
19690         ndr_print_uint32(ndr, "flags", r->flags);
19691         ndr_print_uint32(ndr, "size2", r->size2);
19692         ndr_print_ptr(ndr, "client", r->client);
19693         ndr->depth++;
19694         if (r->client) {
19695                 ndr_print_string(ndr, "client", r->client);
19696         }
19697         ndr->depth--;
19698         ndr_print_ptr(ndr, "user", r->user);
19699         ndr->depth++;
19700         if (r->user) {
19701                 ndr_print_string(ndr, "user", r->user);
19702         }
19703         ndr->depth--;
19704         ndr_print_uint32(ndr, "build", r->build);
19705         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19706         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19707         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19708         ndr_print_udlong(ndr, "reserved", r->reserved);
19709         ndr->depth--;
19710 }
19711
19712 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19713 {
19714         if (ndr_flags & NDR_SCALARS) {
19715                 int level = ndr_push_get_switch_value(ndr, r);
19716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19717                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19718                 switch (level) {
19719                         case 1: {
19720                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19721                         break; }
19722
19723                         case 2: {
19724                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19725                         break; }
19726
19727                         case 3: {
19728                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19729                         break; }
19730
19731                         default:
19732                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19733                 }
19734         }
19735         if (ndr_flags & NDR_BUFFERS) {
19736                 int level = ndr_push_get_switch_value(ndr, r);
19737                 switch (level) {
19738                         case 1:
19739                                 if (r->level1) {
19740                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19741                                 }
19742                         break;
19743
19744                         case 2:
19745                                 if (r->level2) {
19746                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19747                                 }
19748                         break;
19749
19750                         case 3:
19751                                 if (r->level3) {
19752                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19753                                 }
19754                         break;
19755
19756                         default:
19757                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19758                 }
19759         }
19760         return NDR_ERR_SUCCESS;
19761 }
19762
19763 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19764 {
19765         int level;
19766         uint32_t _level;
19767         TALLOC_CTX *_mem_save_level1_0;
19768         uint32_t _ptr_level1;
19769         TALLOC_CTX *_mem_save_level2_0;
19770         uint32_t _ptr_level2;
19771         TALLOC_CTX *_mem_save_level3_0;
19772         uint32_t _ptr_level3;
19773         level = ndr_pull_get_switch_value(ndr, r);
19774         if (ndr_flags & NDR_SCALARS) {
19775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19776                 if (_level != level) {
19777                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19778                 }
19779                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19780                 switch (level) {
19781                         case 1: {
19782                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19783                                 if (_ptr_level1) {
19784                                         NDR_PULL_ALLOC(ndr, r->level1);
19785                                 } else {
19786                                         r->level1 = NULL;
19787                                 }
19788                         break; }
19789
19790                         case 2: {
19791                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19792                                 if (_ptr_level2) {
19793                                         NDR_PULL_ALLOC(ndr, r->level2);
19794                                 } else {
19795                                         r->level2 = NULL;
19796                                 }
19797                         break; }
19798
19799                         case 3: {
19800                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19801                                 if (_ptr_level3) {
19802                                         NDR_PULL_ALLOC(ndr, r->level3);
19803                                 } else {
19804                                         r->level3 = NULL;
19805                                 }
19806                         break; }
19807
19808                         default:
19809                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19810                 }
19811         }
19812         if (ndr_flags & NDR_BUFFERS) {
19813                 switch (level) {
19814                         case 1:
19815                                 if (r->level1) {
19816                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19817                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19818                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19819                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19820                                 }
19821                         break;
19822
19823                         case 2:
19824                                 if (r->level2) {
19825                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19826                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19827                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19828                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19829                                 }
19830                         break;
19831
19832                         case 3:
19833                                 if (r->level3) {
19834                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19835                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19836                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19837                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19838                                 }
19839                         break;
19840
19841                         default:
19842                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19843                 }
19844         }
19845         return NDR_ERR_SUCCESS;
19846 }
19847
19848 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19849 {
19850         int level;
19851         level = ndr_print_get_switch_value(ndr, r);
19852         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19853         switch (level) {
19854                 case 1:
19855                         ndr_print_ptr(ndr, "level1", r->level1);
19856                         ndr->depth++;
19857                         if (r->level1) {
19858                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19859                         }
19860                         ndr->depth--;
19861                 break;
19862
19863                 case 2:
19864                         ndr_print_ptr(ndr, "level2", r->level2);
19865                         ndr->depth++;
19866                         if (r->level2) {
19867                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19868                         }
19869                         ndr->depth--;
19870                 break;
19871
19872                 case 3:
19873                         ndr_print_ptr(ndr, "level3", r->level3);
19874                         ndr->depth++;
19875                         if (r->level3) {
19876                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19877                         }
19878                         ndr->depth--;
19879                 break;
19880
19881                 default:
19882                         ndr_print_bad_level(ndr, name, level);
19883         }
19884 }
19885
19886 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19887 {
19888         if (ndr_flags & NDR_SCALARS) {
19889                 NDR_CHECK(ndr_push_align(ndr, 5));
19890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19891                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19892                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19893                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19894         }
19895         if (ndr_flags & NDR_BUFFERS) {
19896                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19897         }
19898         return NDR_ERR_SUCCESS;
19899 }
19900
19901 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19902 {
19903         if (ndr_flags & NDR_SCALARS) {
19904                 NDR_CHECK(ndr_pull_align(ndr, 5));
19905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19906                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19907                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19908                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19909         }
19910         if (ndr_flags & NDR_BUFFERS) {
19911                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19912         }
19913         return NDR_ERR_SUCCESS;
19914 }
19915
19916 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19917 {
19918         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19919         ndr->depth++;
19920         ndr_print_uint32(ndr, "level", r->level);
19921         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19922         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19923         ndr->depth--;
19924 }
19925
19926 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19927 {
19928         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19929         return NDR_ERR_SUCCESS;
19930 }
19931
19932 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19933 {
19934         uint32_t v;
19935         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19936         *r = v;
19937         return NDR_ERR_SUCCESS;
19938 }
19939
19940 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19941 {
19942         ndr_print_uint32(ndr, name, r);
19943         ndr->depth++;
19944         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19945         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19946         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19947         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19950         ndr->depth--;
19951 }
19952
19953 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19954 {
19955         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19956         if (ndr_flags & NDR_SCALARS) {
19957                 NDR_CHECK(ndr_push_align(ndr, 5));
19958                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19959                 {
19960                         uint32_t _flags_save_string = ndr->flags;
19961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19962                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19963                         ndr->flags = _flags_save_string;
19964                 }
19965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19966                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19967                 {
19968                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
19969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING|ndr_spoolss_PrinterEnumValues_align(r->type));
19970                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19971                         ndr->flags = _flags_save_DATA_BLOB;
19972                 }
19973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data?r->data->length:0));
19974                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19975         }
19976         if (ndr_flags & NDR_BUFFERS) {
19977                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19978                 {
19979                         uint32_t _flags_save_string = ndr->flags;
19980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19981                         if (r->value_name) {
19982                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value_name));
19983                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19984                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value_name));
19985                         }
19986                         ndr->flags = _flags_save_string;
19987                 }
19988                 {
19989                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
19990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING|ndr_spoolss_PrinterEnumValues_align(r->type));
19991                         if (r->data) {
19992                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data));
19993                                 {
19994                                         struct ndr_push *_ndr_data;
19995                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data?r->data->length:0));
19996                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_data, NDR_SCALARS, *r->data));
19997                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data?r->data->length:0));
19998                                 }
19999                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data));
20000                         }
20001                         ndr->flags = _flags_save_DATA_BLOB;
20002                 }
20003         }
20004         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
20005         return NDR_ERR_SUCCESS;
20006 }
20007
20008 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
20009 {
20010         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
20011         uint32_t _ptr_value_name;
20012         TALLOC_CTX *_mem_save_value_name_0;
20013         uint32_t _ptr_data;
20014         TALLOC_CTX *_mem_save_data_0;
20015         if (ndr_flags & NDR_SCALARS) {
20016                 NDR_CHECK(ndr_pull_align(ndr, 5));
20017                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
20018                 {
20019                         uint32_t _flags_save_string = ndr->flags;
20020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
20021                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
20022                         if (_ptr_value_name) {
20023                                 NDR_PULL_ALLOC(ndr, r->value_name);
20024                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
20025                         } else {
20026                                 r->value_name = NULL;
20027                         }
20028                         ndr->flags = _flags_save_string;
20029                 }
20030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
20031                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
20032                 {
20033                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
20034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING|ndr_spoolss_PrinterEnumValues_align(r->type));
20035                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
20036                         if (_ptr_data) {
20037                                 NDR_PULL_ALLOC(ndr, r->data);
20038                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
20039                         } else {
20040                                 r->data = NULL;
20041                         }
20042                         ndr->flags = _flags_save_DATA_BLOB;
20043                 }
20044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
20045                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
20046         }
20047         if (ndr_flags & NDR_BUFFERS) {
20048                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
20049                 {
20050                         uint32_t _flags_save_string = ndr->flags;
20051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
20052                         if (r->value_name) {
20053                                 uint32_t _relative_save_offset;
20054                                 _relative_save_offset = ndr->offset;
20055                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
20056                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
20057                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
20058                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
20059                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
20060                                 ndr->offset = _relative_save_offset;
20061                         }
20062                         ndr->flags = _flags_save_string;
20063                 }
20064                 {
20065                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
20066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING|ndr_spoolss_PrinterEnumValues_align(r->type));
20067                         if (r->data) {
20068                                 uint32_t _relative_save_offset;
20069                                 _relative_save_offset = ndr->offset;
20070                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
20071                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
20072                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
20073                                 {
20074                                         struct ndr_pull *_ndr_data;
20075                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
20076                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_data, NDR_SCALARS, r->data));
20077                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
20078                                 }
20079                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
20080                                 ndr->offset = _relative_save_offset;
20081                         }
20082                         ndr->flags = _flags_save_DATA_BLOB;
20083                 }
20084         }
20085         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
20086         return NDR_ERR_SUCCESS;
20087 }
20088
20089 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
20090 {
20091         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
20092         ndr->depth++;
20093         ndr_print_ptr(ndr, "value_name", r->value_name);
20094         ndr->depth++;
20095         if (r->value_name) {
20096                 ndr_print_string(ndr, "value_name", r->value_name);
20097         }
20098         ndr->depth--;
20099         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
20100         ndr_print_winreg_Type(ndr, "type", r->type);
20101         ndr_print_ptr(ndr, "data", r->data);
20102         ndr->depth++;
20103         if (r->data) {
20104                 ndr_print_DATA_BLOB(ndr, "data", *r->data);
20105         }
20106         ndr->depth--;
20107         ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->data?r->data->length:0:r->data_length);
20108         ndr->depth--;
20109 }
20110
20111 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
20112 {
20113         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
20114 }
20115
20116 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
20117 {
20118         if (ndr_flags & NDR_SCALARS) {
20119                 int level = ndr_push_get_switch_value(ndr, r);
20120                 NDR_CHECK(ndr_push_union_align(ndr, 4));
20121                 switch (level) {
20122                         case 0: {
20123                         break; }
20124
20125                         case 1: {
20126                         break; }
20127
20128                         default: {
20129                                 {
20130                                         uint32_t _flags_save_string_array = ndr->flags;
20131                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
20132                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
20133                                         ndr->flags = _flags_save_string_array;
20134                                 }
20135                         break; }
20136
20137                 }
20138         }
20139         if (ndr_flags & NDR_BUFFERS) {
20140                 int level = ndr_push_get_switch_value(ndr, r);
20141                 switch (level) {
20142                         case 0:
20143                         break;
20144
20145                         case 1:
20146                         break;
20147
20148                         default:
20149                         break;
20150
20151                 }
20152         }
20153         return NDR_ERR_SUCCESS;
20154 }
20155
20156 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
20157 {
20158         int level;
20159         level = ndr_pull_get_switch_value(ndr, r);
20160         if (ndr_flags & NDR_SCALARS) {
20161                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
20162                 switch (level) {
20163                         case 0: {
20164                         break; }
20165
20166                         case 1: {
20167                         break; }
20168
20169                         default: {
20170                                 {
20171                                         uint32_t _flags_save_string_array = ndr->flags;
20172                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
20173                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
20174                                         ndr->flags = _flags_save_string_array;
20175                                 }
20176                         break; }
20177
20178                 }
20179         }
20180         if (ndr_flags & NDR_BUFFERS) {
20181                 switch (level) {
20182                         case 0:
20183                         break;
20184
20185                         case 1:
20186                         break;
20187
20188                         default:
20189                         break;
20190
20191                 }
20192         }
20193         return NDR_ERR_SUCCESS;
20194 }
20195
20196 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
20197 {
20198         int level;
20199         level = ndr_print_get_switch_value(ndr, r);
20200         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
20201         switch (level) {
20202                 case 0:
20203                 break;
20204
20205                 case 1:
20206                 break;
20207
20208                 default:
20209                         ndr_print_string_array(ndr, "string_array", r->string_array);
20210                 break;
20211
20212         }
20213 }
20214
20215 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20216 {
20217         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20218         return NDR_ERR_SUCCESS;
20219 }
20220
20221 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20222 {
20223         uint32_t v;
20224         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20225         *r = v;
20226         return NDR_ERR_SUCCESS;
20227 }
20228
20229 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20230 {
20231         ndr_print_uint32(ndr, name, r);
20232         ndr->depth++;
20233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
20234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
20235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
20236         ndr->depth--;
20237 }
20238
20239 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
20240 {
20241         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
20242         return NDR_ERR_SUCCESS;
20243 }
20244
20245 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
20246 {
20247         uint32_t v;
20248         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
20249         *r = v;
20250         return NDR_ERR_SUCCESS;
20251 }
20252
20253 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
20254 {
20255         const char *val = NULL;
20256
20257         switch (r) {
20258                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
20259                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
20260         }
20261         ndr_print_enum(ndr, name, "ENUM", val, r);
20262 }
20263
20264 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
20265 {
20266         if (ndr_flags & NDR_SCALARS) {
20267                 NDR_CHECK(ndr_push_align(ndr, 4));
20268                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
20270                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20273                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20274                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20276                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20277                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20278                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20279                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20283                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20284         }
20285         if (ndr_flags & NDR_BUFFERS) {
20286         }
20287         return NDR_ERR_SUCCESS;
20288 }
20289
20290 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
20291 {
20292         uint32_t size_portname_0 = 0;
20293         uint32_t size_hostaddress_0 = 0;
20294         uint32_t size_snmpcommunity_0 = 0;
20295         uint32_t size_queue_0 = 0;
20296         uint32_t size_ip_address_0 = 0;
20297         uint32_t size_hardware_address_0 = 0;
20298         uint32_t size_device_type_0 = 0;
20299         if (ndr_flags & NDR_SCALARS) {
20300                 NDR_CHECK(ndr_pull_align(ndr, 4));
20301                 size_portname_0 = 64;
20302                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, size_portname_0, sizeof(uint16_t), CH_UTF16));
20303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20304                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20307                 size_hostaddress_0 = 49;
20308                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, size_hostaddress_0, sizeof(uint16_t), CH_UTF16));
20309                 size_snmpcommunity_0 = 33;
20310                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, size_snmpcommunity_0, sizeof(uint16_t), CH_UTF16));
20311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20312                 size_queue_0 = 33;
20313                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, size_queue_0, sizeof(uint16_t), CH_UTF16));
20314                 size_ip_address_0 = 16;
20315                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, size_ip_address_0, sizeof(uint16_t), CH_UTF16));
20316                 size_hardware_address_0 = 13;
20317                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, size_hardware_address_0, sizeof(uint16_t), CH_UTF16));
20318                 size_device_type_0 = 257;
20319                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, size_device_type_0, sizeof(uint16_t), CH_UTF16));
20320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20323                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20324         }
20325         if (ndr_flags & NDR_BUFFERS) {
20326         }
20327         return NDR_ERR_SUCCESS;
20328 }
20329
20330 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
20331 {
20332         ndr_print_struct(ndr, name, "spoolss_PortData1");
20333         ndr->depth++;
20334         ndr_print_string(ndr, "portname", r->portname);
20335         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
20336         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20337         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20338         ndr_print_uint32(ndr, "reserved", r->reserved);
20339         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20340         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20341         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20342         ndr_print_string(ndr, "queue", r->queue);
20343         ndr_print_string(ndr, "ip_address", r->ip_address);
20344         ndr_print_string(ndr, "hardware_address", r->hardware_address);
20345         ndr_print_string(ndr, "device_type", r->device_type);
20346         ndr_print_uint32(ndr, "port_number", r->port_number);
20347         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20348         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20349         ndr->depth--;
20350 }
20351
20352 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
20353 {
20354         if (ndr_flags & NDR_SCALARS) {
20355                 NDR_CHECK(ndr_push_align(ndr, 4));
20356                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
20358                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20361                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20362                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20364                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20365                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
20370                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20371         }
20372         if (ndr_flags & NDR_BUFFERS) {
20373         }
20374         return NDR_ERR_SUCCESS;
20375 }
20376
20377 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
20378 {
20379         uint32_t size_portname_0 = 0;
20380         uint32_t size_hostaddress_0 = 0;
20381         uint32_t size_snmpcommunity_0 = 0;
20382         uint32_t size_queue_0 = 0;
20383         uint32_t size_device_type_0 = 0;
20384         if (ndr_flags & NDR_SCALARS) {
20385                 NDR_CHECK(ndr_pull_align(ndr, 4));
20386                 size_portname_0 = 64;
20387                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, size_portname_0, sizeof(uint16_t), CH_UTF16));
20388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20389                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20392                 size_hostaddress_0 = 128;
20393                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, size_hostaddress_0, sizeof(uint16_t), CH_UTF16));
20394                 size_snmpcommunity_0 = 33;
20395                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, size_snmpcommunity_0, sizeof(uint16_t), CH_UTF16));
20396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20397                 size_queue_0 = 33;
20398                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, size_queue_0, sizeof(uint16_t), CH_UTF16));
20399                 size_device_type_0 = 257;
20400                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, size_device_type_0, sizeof(uint16_t), CH_UTF16));
20401                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
20405                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20406         }
20407         if (ndr_flags & NDR_BUFFERS) {
20408         }
20409         return NDR_ERR_SUCCESS;
20410 }
20411
20412 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
20413 {
20414         ndr_print_struct(ndr, name, "spoolss_PortData2");
20415         ndr->depth++;
20416         ndr_print_string(ndr, "portname", r->portname);
20417         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
20418         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20419         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20420         ndr_print_uint32(ndr, "reserved", r->reserved);
20421         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20422         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20423         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20424         ndr_print_string(ndr, "queue", r->queue);
20425         ndr_print_string(ndr, "device_type", r->device_type);
20426         ndr_print_uint32(ndr, "port_number", r->port_number);
20427         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20428         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20429         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
20430         ndr->depth--;
20431 }
20432
20433 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
20434 {
20435         if (ndr_flags & NDR_SCALARS) {
20436                 NDR_CHECK(ndr_push_align(ndr, 4));
20437                 {
20438                         uint32_t _flags_save_string = ndr->flags;
20439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
20440                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
20441                         ndr->flags = _flags_save_string;
20442                 }
20443                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20444         }
20445         if (ndr_flags & NDR_BUFFERS) {
20446         }
20447         return NDR_ERR_SUCCESS;
20448 }
20449
20450 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
20451 {
20452         if (ndr_flags & NDR_SCALARS) {
20453                 NDR_CHECK(ndr_pull_align(ndr, 4));
20454                 {
20455                         uint32_t _flags_save_string = ndr->flags;
20456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
20457                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
20458                         ndr->flags = _flags_save_string;
20459                 }
20460                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20461         }
20462         if (ndr_flags & NDR_BUFFERS) {
20463         }
20464         return NDR_ERR_SUCCESS;
20465 }
20466
20467 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
20468 {
20469         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
20470         ndr->depth++;
20471         ndr_print_string(ndr, "dll_name", r->dll_name);
20472         ndr->depth--;
20473 }
20474
20475 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20476 {
20477         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20478         return NDR_ERR_SUCCESS;
20479 }
20480
20481 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20482 {
20483         uint32_t v;
20484         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20485         *r = v;
20486         return NDR_ERR_SUCCESS;
20487 }
20488
20489 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20490 {
20491         ndr_print_uint32(ndr, name, r);
20492         ndr->depth++;
20493         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
20494         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
20495         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
20496         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
20497         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
20498         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
20499         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
20500         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
20501         ndr->depth--;
20502 }
20503
20504 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
20505 {
20506         if (ndr_flags & NDR_SCALARS) {
20507                 NDR_CHECK(ndr_push_align(ndr, 8));
20508                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20509                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
20510                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
20511                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
20512                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20513         }
20514         if (ndr_flags & NDR_BUFFERS) {
20515         }
20516         return NDR_ERR_SUCCESS;
20517 }
20518
20519 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
20520 {
20521         uint32_t size_formname_0 = 0;
20522         if (ndr_flags & NDR_SCALARS) {
20523                 NDR_CHECK(ndr_pull_align(ndr, 8));
20524                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20525                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
20526                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
20527                 size_formname_0 = 520;
20528                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, size_formname_0, sizeof(uint8_t), CH_UTF8));
20529                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
20530         }
20531         if (ndr_flags & NDR_BUFFERS) {
20532         }
20533         return NDR_ERR_SUCCESS;
20534 }
20535
20536 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20537 {
20538         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20539         ndr->depth++;
20540         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20541         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20542         ndr_print_hyper(ndr, "driver_version", r->driver_version);
20543         ndr_print_string(ndr, "formname", r->formname);
20544         ndr->depth--;
20545 }
20546
20547 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20548 {
20549         if (flags & NDR_IN) {
20550                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20551                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20552                 if (r->in.server) {
20553                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20554                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20555                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20556                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20557                 }
20558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20559                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20560                 if (r->in.buffer) {
20561                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20562                 }
20563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20564         }
20565         if (flags & NDR_OUT) {
20566                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20567                 if (r->out.info) {
20568                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20569                 }
20570                 if (r->out.needed == NULL) {
20571                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20572                 }
20573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20574                 if (r->out.count == NULL) {
20575                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20576                 }
20577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20578                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20579         }
20580         return NDR_ERR_SUCCESS;
20581 }
20582
20583 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20584 {
20585         uint32_t _ptr_server;
20586         uint32_t size_server_1 = 0;
20587         uint32_t length_server_1 = 0;
20588         uint32_t _ptr_buffer;
20589         uint32_t _ptr_info;
20590         TALLOC_CTX *_mem_save_server_0;
20591         TALLOC_CTX *_mem_save_buffer_0;
20592         TALLOC_CTX *_mem_save_info_0;
20593         TALLOC_CTX *_mem_save_needed_0;
20594         TALLOC_CTX *_mem_save_count_0;
20595         if (flags & NDR_IN) {
20596                 ZERO_STRUCT(r->out);
20597
20598                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20600                 if (_ptr_server) {
20601                         NDR_PULL_ALLOC(ndr, r->in.server);
20602                 } else {
20603                         r->in.server = NULL;
20604                 }
20605                 if (r->in.server) {
20606                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20607                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20610                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
20611                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
20612                         if (length_server_1 > size_server_1) {
20613                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
20614                         }
20615                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
20616                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
20617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20618                 }
20619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20621                 if (_ptr_buffer) {
20622                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20623                 } else {
20624                         r->in.buffer = NULL;
20625                 }
20626                 if (r->in.buffer) {
20627                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20628                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20629                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20631                 }
20632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20633                 NDR_PULL_ALLOC(ndr, r->out.needed);
20634                 ZERO_STRUCTP(r->out.needed);
20635                 NDR_PULL_ALLOC(ndr, r->out.count);
20636                 ZERO_STRUCTP(r->out.count);
20637         }
20638         if (flags & NDR_OUT) {
20639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20640                 if (_ptr_info) {
20641                         NDR_PULL_ALLOC(ndr, r->out.info);
20642                 } else {
20643                         r->out.info = NULL;
20644                 }
20645                 if (r->out.info) {
20646                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20647                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20648                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20650                 }
20651                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20652                         NDR_PULL_ALLOC(ndr, r->out.needed);
20653                 }
20654                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20655                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20657                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20658                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20659                         NDR_PULL_ALLOC(ndr, r->out.count);
20660                 }
20661                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20662                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20664                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20665                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20666         }
20667         return NDR_ERR_SUCCESS;
20668 }
20669
20670 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20671 {
20672         uint32_t cntr_info_0;
20673         if (flags & NDR_IN) {
20674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20676         }
20677         if (flags & NDR_OUT) {
20678                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20679                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20680                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20681                 }
20682                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20683                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20684                 }
20685         }
20686         return NDR_ERR_SUCCESS;
20687 }
20688
20689 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20690 {
20691         uint32_t size_info_0 = 0;
20692         uint32_t cntr_info_0;
20693         TALLOC_CTX *_mem_save_info_0;
20694         if (flags & NDR_IN) {
20695                 ZERO_STRUCT(r->out);
20696
20697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20699         }
20700         if (flags & NDR_OUT) {
20701                 size_info_0 = r->in.count;
20702                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
20703                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20704                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20705                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
20706                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20707                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20708                 }
20709                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
20710                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20711                 }
20712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20713         }
20714         return NDR_ERR_SUCCESS;
20715 }
20716
20717 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20718 {
20719         uint32_t cntr_info_2;
20720         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20721         ndr->depth++;
20722         if (flags & NDR_SET_VALUES) {
20723                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20724         }
20725         if (flags & NDR_IN) {
20726                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20727                 ndr->depth++;
20728                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20729                 ndr_print_ptr(ndr, "server", r->in.server);
20730                 ndr->depth++;
20731                 if (r->in.server) {
20732                         ndr_print_string(ndr, "server", r->in.server);
20733                 }
20734                 ndr->depth--;
20735                 ndr_print_uint32(ndr, "level", r->in.level);
20736                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20737                 ndr->depth++;
20738                 if (r->in.buffer) {
20739                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20740                 }
20741                 ndr->depth--;
20742                 ndr_print_uint32(ndr, "offered", r->in.offered);
20743                 ndr->depth--;
20744         }
20745         if (flags & NDR_OUT) {
20746                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20747                 ndr->depth++;
20748                 ndr_print_ptr(ndr, "count", r->out.count);
20749                 ndr->depth++;
20750                 ndr_print_uint32(ndr, "count", *r->out.count);
20751                 ndr->depth--;
20752                 ndr_print_ptr(ndr, "info", r->out.info);
20753                 ndr->depth++;
20754                 ndr_print_ptr(ndr, "info", *r->out.info);
20755                 ndr->depth++;
20756                 if (*r->out.info) {
20757                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20758                         ndr->depth++;
20759                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20760                                 char *idx_2=NULL;
20761                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20762                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20763                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20764                                         free(idx_2);
20765                                 }
20766                         }
20767                         ndr->depth--;
20768                 }
20769                 ndr->depth--;
20770                 ndr->depth--;
20771                 ndr_print_ptr(ndr, "needed", r->out.needed);
20772                 ndr->depth++;
20773                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20774                 ndr->depth--;
20775                 ndr_print_WERROR(ndr, "result", r->out.result);
20776                 ndr->depth--;
20777         }
20778         ndr->depth--;
20779 }
20780
20781 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20782 {
20783         if (flags & NDR_IN) {
20784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20785                 if (r->in.printername) {
20786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20787                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20789                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20790                 }
20791                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20792                 if (r->in.datatype) {
20793                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20796                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20797                 }
20798                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20799                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20800         }
20801         if (flags & NDR_OUT) {
20802                 if (r->out.handle == NULL) {
20803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20804                 }
20805                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20806                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20807         }
20808         return NDR_ERR_SUCCESS;
20809 }
20810
20811 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20812 {
20813         uint32_t _ptr_printername;
20814         uint32_t size_printername_1 = 0;
20815         uint32_t length_printername_1 = 0;
20816         uint32_t _ptr_datatype;
20817         uint32_t size_datatype_1 = 0;
20818         uint32_t length_datatype_1 = 0;
20819         TALLOC_CTX *_mem_save_printername_0;
20820         TALLOC_CTX *_mem_save_datatype_0;
20821         TALLOC_CTX *_mem_save_handle_0;
20822         if (flags & NDR_IN) {
20823                 ZERO_STRUCT(r->out);
20824
20825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20826                 if (_ptr_printername) {
20827                         NDR_PULL_ALLOC(ndr, r->in.printername);
20828                 } else {
20829                         r->in.printername = NULL;
20830                 }
20831                 if (r->in.printername) {
20832                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20833                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20834                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20835                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20836                         size_printername_1 = ndr_get_array_size(ndr, &r->in.printername);
20837                         length_printername_1 = ndr_get_array_length(ndr, &r->in.printername);
20838                         if (length_printername_1 > size_printername_1) {
20839                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printername_1, length_printername_1);
20840                         }
20841                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printername_1, sizeof(uint16_t)));
20842                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, length_printername_1, sizeof(uint16_t), CH_UTF16));
20843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20844                 }
20845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20846                 if (_ptr_datatype) {
20847                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20848                 } else {
20849                         r->in.datatype = NULL;
20850                 }
20851                 if (r->in.datatype) {
20852                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20853                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20854                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20855                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20856                         size_datatype_1 = ndr_get_array_size(ndr, &r->in.datatype);
20857                         length_datatype_1 = ndr_get_array_length(ndr, &r->in.datatype);
20858                         if (length_datatype_1 > size_datatype_1) {
20859                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_datatype_1, length_datatype_1);
20860                         }
20861                         NDR_CHECK(ndr_check_string_terminator(ndr, length_datatype_1, sizeof(uint16_t)));
20862                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, length_datatype_1, sizeof(uint16_t), CH_UTF16));
20863                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20864                 }
20865                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20866                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20867                 NDR_PULL_ALLOC(ndr, r->out.handle);
20868                 ZERO_STRUCTP(r->out.handle);
20869         }
20870         if (flags & NDR_OUT) {
20871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20872                         NDR_PULL_ALLOC(ndr, r->out.handle);
20873                 }
20874                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20875                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20879         }
20880         return NDR_ERR_SUCCESS;
20881 }
20882
20883 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20884 {
20885         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20886         ndr->depth++;
20887         if (flags & NDR_SET_VALUES) {
20888                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20889         }
20890         if (flags & NDR_IN) {
20891                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20892                 ndr->depth++;
20893                 ndr_print_ptr(ndr, "printername", r->in.printername);
20894                 ndr->depth++;
20895                 if (r->in.printername) {
20896                         ndr_print_string(ndr, "printername", r->in.printername);
20897                 }
20898                 ndr->depth--;
20899                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20900                 ndr->depth++;
20901                 if (r->in.datatype) {
20902                         ndr_print_string(ndr, "datatype", r->in.datatype);
20903                 }
20904                 ndr->depth--;
20905                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20906                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20907                 ndr->depth--;
20908         }
20909         if (flags & NDR_OUT) {
20910                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20911                 ndr->depth++;
20912                 ndr_print_ptr(ndr, "handle", r->out.handle);
20913                 ndr->depth++;
20914                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20915                 ndr->depth--;
20916                 ndr_print_WERROR(ndr, "result", r->out.result);
20917                 ndr->depth--;
20918         }
20919         ndr->depth--;
20920 }
20921
20922 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20923 {
20924         if (flags & NDR_IN) {
20925                 if (r->in.handle == NULL) {
20926                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20927                 }
20928                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20930                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20931                 if (r->in.ctr) {
20932                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20933                 }
20934                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20935         }
20936         if (flags & NDR_OUT) {
20937                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20938         }
20939         return NDR_ERR_SUCCESS;
20940 }
20941
20942 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20943 {
20944         uint32_t _ptr_ctr;
20945         TALLOC_CTX *_mem_save_handle_0;
20946         TALLOC_CTX *_mem_save_ctr_0;
20947         if (flags & NDR_IN) {
20948                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20949                         NDR_PULL_ALLOC(ndr, r->in.handle);
20950                 }
20951                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20952                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20953                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20957                 if (_ptr_ctr) {
20958                         NDR_PULL_ALLOC(ndr, r->in.ctr);
20959                 } else {
20960                         r->in.ctr = NULL;
20961                 }
20962                 if (r->in.ctr) {
20963                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20964                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20965                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20967                 }
20968                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20969         }
20970         if (flags & NDR_OUT) {
20971                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20972         }
20973         return NDR_ERR_SUCCESS;
20974 }
20975
20976 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20977 {
20978         ndr_print_struct(ndr, name, "spoolss_SetJob");
20979         ndr->depth++;
20980         if (flags & NDR_SET_VALUES) {
20981                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20982         }
20983         if (flags & NDR_IN) {
20984                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20985                 ndr->depth++;
20986                 ndr_print_ptr(ndr, "handle", r->in.handle);
20987                 ndr->depth++;
20988                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20989                 ndr->depth--;
20990                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20991                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20992                 ndr->depth++;
20993                 if (r->in.ctr) {
20994                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20995                 }
20996                 ndr->depth--;
20997                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20998                 ndr->depth--;
20999         }
21000         if (flags & NDR_OUT) {
21001                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
21002                 ndr->depth++;
21003                 ndr_print_WERROR(ndr, "result", r->out.result);
21004                 ndr->depth--;
21005         }
21006         ndr->depth--;
21007 }
21008
21009 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
21010 {
21011         if (flags & NDR_IN) {
21012                 if (r->in.handle == NULL) {
21013                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21014                 }
21015                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
21017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21019                 if (r->in.buffer) {
21020                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21021                 }
21022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21023         }
21024         if (flags & NDR_OUT) {
21025                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21026                 if (r->out.info) {
21027                         {
21028                                 struct ndr_push *_ndr_info;
21029                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21030                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21031                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21032                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21033                         }
21034                 }
21035                 if (r->out.needed == NULL) {
21036                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21037                 }
21038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21039                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21040         }
21041         return NDR_ERR_SUCCESS;
21042 }
21043
21044 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
21045 {
21046         uint32_t _ptr_buffer;
21047         uint32_t _ptr_info;
21048         TALLOC_CTX *_mem_save_handle_0;
21049         TALLOC_CTX *_mem_save_buffer_0;
21050         TALLOC_CTX *_mem_save_info_0;
21051         TALLOC_CTX *_mem_save_needed_0;
21052         if (flags & NDR_IN) {
21053                 ZERO_STRUCT(r->out);
21054
21055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21056                         NDR_PULL_ALLOC(ndr, r->in.handle);
21057                 }
21058                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21059                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21060                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
21063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21065                 if (_ptr_buffer) {
21066                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21067                 } else {
21068                         r->in.buffer = NULL;
21069                 }
21070                 if (r->in.buffer) {
21071                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21072                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21073                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21075                 }
21076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21077                 NDR_PULL_ALLOC(ndr, r->out.needed);
21078                 ZERO_STRUCTP(r->out.needed);
21079         }
21080         if (flags & NDR_OUT) {
21081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21082                 if (_ptr_info) {
21083                         NDR_PULL_ALLOC(ndr, r->out.info);
21084                 } else {
21085                         r->out.info = NULL;
21086                 }
21087                 if (r->out.info) {
21088                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21089                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21090                         {
21091                                 struct ndr_pull *_ndr_info;
21092                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21093                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21094                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21095                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21096                         }
21097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21098                 }
21099                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21100                         NDR_PULL_ALLOC(ndr, r->out.needed);
21101                 }
21102                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21103                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21105                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21106                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21107         }
21108         return NDR_ERR_SUCCESS;
21109 }
21110
21111 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
21112 {
21113         ndr_print_struct(ndr, name, "spoolss_GetJob");
21114         ndr->depth++;
21115         if (flags & NDR_SET_VALUES) {
21116                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21117         }
21118         if (flags & NDR_IN) {
21119                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
21120                 ndr->depth++;
21121                 ndr_print_ptr(ndr, "handle", r->in.handle);
21122                 ndr->depth++;
21123                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21124                 ndr->depth--;
21125                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
21126                 ndr_print_uint32(ndr, "level", r->in.level);
21127                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21128                 ndr->depth++;
21129                 if (r->in.buffer) {
21130                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21131                 }
21132                 ndr->depth--;
21133                 ndr_print_uint32(ndr, "offered", r->in.offered);
21134                 ndr->depth--;
21135         }
21136         if (flags & NDR_OUT) {
21137                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
21138                 ndr->depth++;
21139                 ndr_print_ptr(ndr, "info", r->out.info);
21140                 ndr->depth++;
21141                 if (r->out.info) {
21142                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21143                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
21144                 }
21145                 ndr->depth--;
21146                 ndr_print_ptr(ndr, "needed", r->out.needed);
21147                 ndr->depth++;
21148                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21149                 ndr->depth--;
21150                 ndr_print_WERROR(ndr, "result", r->out.result);
21151                 ndr->depth--;
21152         }
21153         ndr->depth--;
21154 }
21155
21156 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
21157 {
21158         if (flags & NDR_IN) {
21159                 if (r->in.handle == NULL) {
21160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21161                 }
21162                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
21164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
21165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21166                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21167                 if (r->in.buffer) {
21168                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21169                 }
21170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21171         }
21172         if (flags & NDR_OUT) {
21173                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21174                 if (r->out.info) {
21175                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21176                 }
21177                 if (r->out.needed == NULL) {
21178                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21179                 }
21180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21181                 if (r->out.count == NULL) {
21182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21183                 }
21184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21185                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21186         }
21187         return NDR_ERR_SUCCESS;
21188 }
21189
21190 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
21191 {
21192         uint32_t _ptr_buffer;
21193         uint32_t _ptr_info;
21194         TALLOC_CTX *_mem_save_handle_0;
21195         TALLOC_CTX *_mem_save_buffer_0;
21196         TALLOC_CTX *_mem_save_info_0;
21197         TALLOC_CTX *_mem_save_needed_0;
21198         TALLOC_CTX *_mem_save_count_0;
21199         if (flags & NDR_IN) {
21200                 ZERO_STRUCT(r->out);
21201
21202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21203                         NDR_PULL_ALLOC(ndr, r->in.handle);
21204                 }
21205                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21207                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
21210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
21211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21212                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21213                 if (_ptr_buffer) {
21214                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21215                 } else {
21216                         r->in.buffer = NULL;
21217                 }
21218                 if (r->in.buffer) {
21219                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21220                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21221                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21222                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21223                 }
21224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21225                 NDR_PULL_ALLOC(ndr, r->out.needed);
21226                 ZERO_STRUCTP(r->out.needed);
21227                 NDR_PULL_ALLOC(ndr, r->out.count);
21228                 ZERO_STRUCTP(r->out.count);
21229         }
21230         if (flags & NDR_OUT) {
21231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21232                 if (_ptr_info) {
21233                         NDR_PULL_ALLOC(ndr, r->out.info);
21234                 } else {
21235                         r->out.info = NULL;
21236                 }
21237                 if (r->out.info) {
21238                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21239                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21240                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21241                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21242                 }
21243                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21244                         NDR_PULL_ALLOC(ndr, r->out.needed);
21245                 }
21246                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21247                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21249                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21250                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21251                         NDR_PULL_ALLOC(ndr, r->out.count);
21252                 }
21253                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21254                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21256                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21257                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21258         }
21259         return NDR_ERR_SUCCESS;
21260 }
21261
21262 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
21263 {
21264         uint32_t cntr_info_0;
21265         if (flags & NDR_IN) {
21266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21268         }
21269         if (flags & NDR_OUT) {
21270                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21271                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21272                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21273                 }
21274                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21275                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21276                 }
21277         }
21278         return NDR_ERR_SUCCESS;
21279 }
21280
21281 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
21282 {
21283         uint32_t size_info_0 = 0;
21284         uint32_t cntr_info_0;
21285         TALLOC_CTX *_mem_save_info_0;
21286         if (flags & NDR_IN) {
21287                 ZERO_STRUCT(r->out);
21288
21289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21291         }
21292         if (flags & NDR_OUT) {
21293                 size_info_0 = r->in.count;
21294                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
21295                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21296                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21297                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
21298                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21299                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21300                 }
21301                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
21302                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21303                 }
21304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21305         }
21306         return NDR_ERR_SUCCESS;
21307 }
21308
21309 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
21310 {
21311         uint32_t cntr_info_2;
21312         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
21313         ndr->depth++;
21314         if (flags & NDR_SET_VALUES) {
21315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21316         }
21317         if (flags & NDR_IN) {
21318                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
21319                 ndr->depth++;
21320                 ndr_print_ptr(ndr, "handle", r->in.handle);
21321                 ndr->depth++;
21322                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21323                 ndr->depth--;
21324                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
21325                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
21326                 ndr_print_uint32(ndr, "level", r->in.level);
21327                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21328                 ndr->depth++;
21329                 if (r->in.buffer) {
21330                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21331                 }
21332                 ndr->depth--;
21333                 ndr_print_uint32(ndr, "offered", r->in.offered);
21334                 ndr->depth--;
21335         }
21336         if (flags & NDR_OUT) {
21337                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
21338                 ndr->depth++;
21339                 ndr_print_ptr(ndr, "count", r->out.count);
21340                 ndr->depth++;
21341                 ndr_print_uint32(ndr, "count", *r->out.count);
21342                 ndr->depth--;
21343                 ndr_print_ptr(ndr, "info", r->out.info);
21344                 ndr->depth++;
21345                 ndr_print_ptr(ndr, "info", *r->out.info);
21346                 ndr->depth++;
21347                 if (*r->out.info) {
21348                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21349                         ndr->depth++;
21350                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21351                                 char *idx_2=NULL;
21352                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21353                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21354                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21355                                         free(idx_2);
21356                                 }
21357                         }
21358                         ndr->depth--;
21359                 }
21360                 ndr->depth--;
21361                 ndr->depth--;
21362                 ndr_print_ptr(ndr, "needed", r->out.needed);
21363                 ndr->depth++;
21364                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21365                 ndr->depth--;
21366                 ndr_print_WERROR(ndr, "result", r->out.result);
21367                 ndr->depth--;
21368         }
21369         ndr->depth--;
21370 }
21371
21372 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
21373 {
21374         if (flags & NDR_IN) {
21375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21376                 if (r->in.server) {
21377                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21380                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21381                 }
21382                 if (r->in.info_ctr == NULL) {
21383                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21384                 }
21385                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21386                 if (r->in.devmode_ctr == NULL) {
21387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21388                 }
21389                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21390                 if (r->in.secdesc_ctr == NULL) {
21391                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21392                 }
21393                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21394         }
21395         if (flags & NDR_OUT) {
21396                 if (r->out.handle == NULL) {
21397                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21398                 }
21399                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21400                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21401         }
21402         return NDR_ERR_SUCCESS;
21403 }
21404
21405 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
21406 {
21407         uint32_t _ptr_server;
21408         uint32_t size_server_1 = 0;
21409         uint32_t length_server_1 = 0;
21410         TALLOC_CTX *_mem_save_server_0;
21411         TALLOC_CTX *_mem_save_info_ctr_0;
21412         TALLOC_CTX *_mem_save_devmode_ctr_0;
21413         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21414         TALLOC_CTX *_mem_save_handle_0;
21415         if (flags & NDR_IN) {
21416                 ZERO_STRUCT(r->out);
21417
21418                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21419                 if (_ptr_server) {
21420                         NDR_PULL_ALLOC(ndr, r->in.server);
21421                 } else {
21422                         r->in.server = NULL;
21423                 }
21424                 if (r->in.server) {
21425                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21426                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21428                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21429                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
21430                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
21431                         if (length_server_1 > size_server_1) {
21432                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
21433                         }
21434                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
21435                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
21436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21437                 }
21438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21439                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21440                 }
21441                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21443                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21446                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21447                 }
21448                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21449                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21450                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21452                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21453                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21454                 }
21455                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21456                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21457                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21459                 NDR_PULL_ALLOC(ndr, r->out.handle);
21460                 ZERO_STRUCTP(r->out.handle);
21461         }
21462         if (flags & NDR_OUT) {
21463                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21464                         NDR_PULL_ALLOC(ndr, r->out.handle);
21465                 }
21466                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21467                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21468                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21470                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21471         }
21472         return NDR_ERR_SUCCESS;
21473 }
21474
21475 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
21476 {
21477         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
21478         ndr->depth++;
21479         if (flags & NDR_SET_VALUES) {
21480                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21481         }
21482         if (flags & NDR_IN) {
21483                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
21484                 ndr->depth++;
21485                 ndr_print_ptr(ndr, "server", r->in.server);
21486                 ndr->depth++;
21487                 if (r->in.server) {
21488                         ndr_print_string(ndr, "server", r->in.server);
21489                 }
21490                 ndr->depth--;
21491                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21492                 ndr->depth++;
21493                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21494                 ndr->depth--;
21495                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21496                 ndr->depth++;
21497                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21498                 ndr->depth--;
21499                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21500                 ndr->depth++;
21501                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21502                 ndr->depth--;
21503                 ndr->depth--;
21504         }
21505         if (flags & NDR_OUT) {
21506                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
21507                 ndr->depth++;
21508                 ndr_print_ptr(ndr, "handle", r->out.handle);
21509                 ndr->depth++;
21510                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21511                 ndr->depth--;
21512                 ndr_print_WERROR(ndr, "result", r->out.result);
21513                 ndr->depth--;
21514         }
21515         ndr->depth--;
21516 }
21517
21518 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
21519 {
21520         if (flags & NDR_IN) {
21521                 if (r->in.handle == NULL) {
21522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21523                 }
21524                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21525         }
21526         if (flags & NDR_OUT) {
21527                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21528         }
21529         return NDR_ERR_SUCCESS;
21530 }
21531
21532 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
21533 {
21534         TALLOC_CTX *_mem_save_handle_0;
21535         if (flags & NDR_IN) {
21536                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21537                         NDR_PULL_ALLOC(ndr, r->in.handle);
21538                 }
21539                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21540                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21541                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21542                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21543         }
21544         if (flags & NDR_OUT) {
21545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21546         }
21547         return NDR_ERR_SUCCESS;
21548 }
21549
21550 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
21551 {
21552         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21553         ndr->depth++;
21554         if (flags & NDR_SET_VALUES) {
21555                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21556         }
21557         if (flags & NDR_IN) {
21558                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21559                 ndr->depth++;
21560                 ndr_print_ptr(ndr, "handle", r->in.handle);
21561                 ndr->depth++;
21562                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21563                 ndr->depth--;
21564                 ndr->depth--;
21565         }
21566         if (flags & NDR_OUT) {
21567                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21568                 ndr->depth++;
21569                 ndr_print_WERROR(ndr, "result", r->out.result);
21570                 ndr->depth--;
21571         }
21572         ndr->depth--;
21573 }
21574
21575 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21576 {
21577         if (flags & NDR_IN) {
21578                 if (r->in.handle == NULL) {
21579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21580                 }
21581                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21582                 if (r->in.info_ctr == NULL) {
21583                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21584                 }
21585                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21586                 if (r->in.devmode_ctr == NULL) {
21587                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21588                 }
21589                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21590                 if (r->in.secdesc_ctr == NULL) {
21591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21592                 }
21593                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21594                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21595         }
21596         if (flags & NDR_OUT) {
21597                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21598         }
21599         return NDR_ERR_SUCCESS;
21600 }
21601
21602 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21603 {
21604         TALLOC_CTX *_mem_save_handle_0;
21605         TALLOC_CTX *_mem_save_info_ctr_0;
21606         TALLOC_CTX *_mem_save_devmode_ctr_0;
21607         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21608         if (flags & NDR_IN) {
21609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21610                         NDR_PULL_ALLOC(ndr, r->in.handle);
21611                 }
21612                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21613                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21614                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21617                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21618                 }
21619                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21620                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21621                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21624                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21625                 }
21626                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21627                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21628                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21630                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21631                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21632                 }
21633                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21634                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21635                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21636                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21637                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21638         }
21639         if (flags & NDR_OUT) {
21640                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21641         }
21642         return NDR_ERR_SUCCESS;
21643 }
21644
21645 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21646 {
21647         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21648         ndr->depth++;
21649         if (flags & NDR_SET_VALUES) {
21650                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21651         }
21652         if (flags & NDR_IN) {
21653                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21654                 ndr->depth++;
21655                 ndr_print_ptr(ndr, "handle", r->in.handle);
21656                 ndr->depth++;
21657                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21658                 ndr->depth--;
21659                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21660                 ndr->depth++;
21661                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21662                 ndr->depth--;
21663                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21664                 ndr->depth++;
21665                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21666                 ndr->depth--;
21667                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21668                 ndr->depth++;
21669                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21670                 ndr->depth--;
21671                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21672                 ndr->depth--;
21673         }
21674         if (flags & NDR_OUT) {
21675                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21676                 ndr->depth++;
21677                 ndr_print_WERROR(ndr, "result", r->out.result);
21678                 ndr->depth--;
21679         }
21680         ndr->depth--;
21681 }
21682
21683 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21684 {
21685         if (flags & NDR_IN) {
21686                 if (r->in.handle == NULL) {
21687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21688                 }
21689                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21692                 if (r->in.buffer) {
21693                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21694                 }
21695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21696         }
21697         if (flags & NDR_OUT) {
21698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21699                 if (r->out.info) {
21700                         {
21701                                 struct ndr_push *_ndr_info;
21702                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21703                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21704                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21705                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21706                         }
21707                 }
21708                 if (r->out.needed == NULL) {
21709                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21710                 }
21711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21712                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21713         }
21714         return NDR_ERR_SUCCESS;
21715 }
21716
21717 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21718 {
21719         uint32_t _ptr_buffer;
21720         uint32_t _ptr_info;
21721         TALLOC_CTX *_mem_save_handle_0;
21722         TALLOC_CTX *_mem_save_buffer_0;
21723         TALLOC_CTX *_mem_save_info_0;
21724         TALLOC_CTX *_mem_save_needed_0;
21725         if (flags & NDR_IN) {
21726                 ZERO_STRUCT(r->out);
21727
21728                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21729                         NDR_PULL_ALLOC(ndr, r->in.handle);
21730                 }
21731                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21732                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21733                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21734                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21737                 if (_ptr_buffer) {
21738                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21739                 } else {
21740                         r->in.buffer = NULL;
21741                 }
21742                 if (r->in.buffer) {
21743                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21744                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21745                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21747                 }
21748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21749                 NDR_PULL_ALLOC(ndr, r->out.needed);
21750                 ZERO_STRUCTP(r->out.needed);
21751         }
21752         if (flags & NDR_OUT) {
21753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21754                 if (_ptr_info) {
21755                         NDR_PULL_ALLOC(ndr, r->out.info);
21756                 } else {
21757                         r->out.info = NULL;
21758                 }
21759                 if (r->out.info) {
21760                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21761                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21762                         {
21763                                 struct ndr_pull *_ndr_info;
21764                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21765                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21766                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21767                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21768                         }
21769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21770                 }
21771                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21772                         NDR_PULL_ALLOC(ndr, r->out.needed);
21773                 }
21774                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21775                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21777                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21778                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21779         }
21780         return NDR_ERR_SUCCESS;
21781 }
21782
21783 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21784 {
21785         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21786         ndr->depth++;
21787         if (flags & NDR_SET_VALUES) {
21788                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21789         }
21790         if (flags & NDR_IN) {
21791                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21792                 ndr->depth++;
21793                 ndr_print_ptr(ndr, "handle", r->in.handle);
21794                 ndr->depth++;
21795                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21796                 ndr->depth--;
21797                 ndr_print_uint32(ndr, "level", r->in.level);
21798                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21799                 ndr->depth++;
21800                 if (r->in.buffer) {
21801                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21802                 }
21803                 ndr->depth--;
21804                 ndr_print_uint32(ndr, "offered", r->in.offered);
21805                 ndr->depth--;
21806         }
21807         if (flags & NDR_OUT) {
21808                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21809                 ndr->depth++;
21810                 ndr_print_ptr(ndr, "info", r->out.info);
21811                 ndr->depth++;
21812                 if (r->out.info) {
21813                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21814                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21815                 }
21816                 ndr->depth--;
21817                 ndr_print_ptr(ndr, "needed", r->out.needed);
21818                 ndr->depth++;
21819                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21820                 ndr->depth--;
21821                 ndr_print_WERROR(ndr, "result", r->out.result);
21822                 ndr->depth--;
21823         }
21824         ndr->depth--;
21825 }
21826
21827 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21828 {
21829         if (flags & NDR_IN) {
21830                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21831                 if (r->in.servername) {
21832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21836                 }
21837                 if (r->in.info_ctr == NULL) {
21838                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21839                 }
21840                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21841         }
21842         if (flags & NDR_OUT) {
21843                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21844         }
21845         return NDR_ERR_SUCCESS;
21846 }
21847
21848 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21849 {
21850         uint32_t _ptr_servername;
21851         uint32_t size_servername_1 = 0;
21852         uint32_t length_servername_1 = 0;
21853         TALLOC_CTX *_mem_save_servername_0;
21854         TALLOC_CTX *_mem_save_info_ctr_0;
21855         if (flags & NDR_IN) {
21856                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21857                 if (_ptr_servername) {
21858                         NDR_PULL_ALLOC(ndr, r->in.servername);
21859                 } else {
21860                         r->in.servername = NULL;
21861                 }
21862                 if (r->in.servername) {
21863                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21864                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21865                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21866                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21867                         size_servername_1 = ndr_get_array_size(ndr, &r->in.servername);
21868                         length_servername_1 = ndr_get_array_length(ndr, &r->in.servername);
21869                         if (length_servername_1 > size_servername_1) {
21870                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
21871                         }
21872                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
21873                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
21874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21875                 }
21876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21877                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21878                 }
21879                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21880                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21881                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21883         }
21884         if (flags & NDR_OUT) {
21885                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21886         }
21887         return NDR_ERR_SUCCESS;
21888 }
21889
21890 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21891 {
21892         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21893         ndr->depth++;
21894         if (flags & NDR_SET_VALUES) {
21895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21896         }
21897         if (flags & NDR_IN) {
21898                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21899                 ndr->depth++;
21900                 ndr_print_ptr(ndr, "servername", r->in.servername);
21901                 ndr->depth++;
21902                 if (r->in.servername) {
21903                         ndr_print_string(ndr, "servername", r->in.servername);
21904                 }
21905                 ndr->depth--;
21906                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21907                 ndr->depth++;
21908                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21909                 ndr->depth--;
21910                 ndr->depth--;
21911         }
21912         if (flags & NDR_OUT) {
21913                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21914                 ndr->depth++;
21915                 ndr_print_WERROR(ndr, "result", r->out.result);
21916                 ndr->depth--;
21917         }
21918         ndr->depth--;
21919 }
21920
21921 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21922 {
21923         if (flags & NDR_IN) {
21924                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21925                 if (r->in.server) {
21926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21929                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21930                 }
21931                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21932                 if (r->in.environment) {
21933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21935                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21937                 }
21938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21940                 if (r->in.buffer) {
21941                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21942                 }
21943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21944         }
21945         if (flags & NDR_OUT) {
21946                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21947                 if (r->out.info) {
21948                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21949                 }
21950                 if (r->out.needed == NULL) {
21951                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21952                 }
21953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21954                 if (r->out.count == NULL) {
21955                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21956                 }
21957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21958                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21959         }
21960         return NDR_ERR_SUCCESS;
21961 }
21962
21963 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21964 {
21965         uint32_t _ptr_server;
21966         uint32_t size_server_1 = 0;
21967         uint32_t length_server_1 = 0;
21968         uint32_t _ptr_environment;
21969         uint32_t size_environment_1 = 0;
21970         uint32_t length_environment_1 = 0;
21971         uint32_t _ptr_buffer;
21972         uint32_t _ptr_info;
21973         TALLOC_CTX *_mem_save_server_0;
21974         TALLOC_CTX *_mem_save_environment_0;
21975         TALLOC_CTX *_mem_save_buffer_0;
21976         TALLOC_CTX *_mem_save_info_0;
21977         TALLOC_CTX *_mem_save_needed_0;
21978         TALLOC_CTX *_mem_save_count_0;
21979         if (flags & NDR_IN) {
21980                 ZERO_STRUCT(r->out);
21981
21982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21983                 if (_ptr_server) {
21984                         NDR_PULL_ALLOC(ndr, r->in.server);
21985                 } else {
21986                         r->in.server = NULL;
21987                 }
21988                 if (r->in.server) {
21989                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21990                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21991                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21992                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21993                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
21994                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
21995                         if (length_server_1 > size_server_1) {
21996                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
21997                         }
21998                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
21999                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
22000                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22001                 }
22002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22003                 if (_ptr_environment) {
22004                         NDR_PULL_ALLOC(ndr, r->in.environment);
22005                 } else {
22006                         r->in.environment = NULL;
22007                 }
22008                 if (r->in.environment) {
22009                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22010                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22011                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22012                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22013                         size_environment_1 = ndr_get_array_size(ndr, &r->in.environment);
22014                         length_environment_1 = ndr_get_array_length(ndr, &r->in.environment);
22015                         if (length_environment_1 > size_environment_1) {
22016                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_environment_1, length_environment_1);
22017                         }
22018                         NDR_CHECK(ndr_check_string_terminator(ndr, length_environment_1, sizeof(uint16_t)));
22019                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, length_environment_1, sizeof(uint16_t), CH_UTF16));
22020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22021                 }
22022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22024                 if (_ptr_buffer) {
22025                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22026                 } else {
22027                         r->in.buffer = NULL;
22028                 }
22029                 if (r->in.buffer) {
22030                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22031                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22032                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22034                 }
22035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22036                 NDR_PULL_ALLOC(ndr, r->out.needed);
22037                 ZERO_STRUCTP(r->out.needed);
22038                 NDR_PULL_ALLOC(ndr, r->out.count);
22039                 ZERO_STRUCTP(r->out.count);
22040         }
22041         if (flags & NDR_OUT) {
22042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22043                 if (_ptr_info) {
22044                         NDR_PULL_ALLOC(ndr, r->out.info);
22045                 } else {
22046                         r->out.info = NULL;
22047                 }
22048                 if (r->out.info) {
22049                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22050                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22051                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22053                 }
22054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22055                         NDR_PULL_ALLOC(ndr, r->out.needed);
22056                 }
22057                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22058                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22061                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22062                         NDR_PULL_ALLOC(ndr, r->out.count);
22063                 }
22064                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22065                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22067                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22068                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22069         }
22070         return NDR_ERR_SUCCESS;
22071 }
22072
22073 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
22074 {
22075         uint32_t cntr_info_0;
22076         if (flags & NDR_IN) {
22077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22079         }
22080         if (flags & NDR_OUT) {
22081                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22082                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22083                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22084                 }
22085                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22086                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22087                 }
22088         }
22089         return NDR_ERR_SUCCESS;
22090 }
22091
22092 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
22093 {
22094         uint32_t size_info_0 = 0;
22095         uint32_t cntr_info_0;
22096         TALLOC_CTX *_mem_save_info_0;
22097         if (flags & NDR_IN) {
22098                 ZERO_STRUCT(r->out);
22099
22100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22102         }
22103         if (flags & NDR_OUT) {
22104                 size_info_0 = r->in.count;
22105                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
22106                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22107                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22108                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
22109                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22110                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22111                 }
22112                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
22113                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22114                 }
22115                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22116         }
22117         return NDR_ERR_SUCCESS;
22118 }
22119
22120 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
22121 {
22122         uint32_t cntr_info_2;
22123         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
22124         ndr->depth++;
22125         if (flags & NDR_SET_VALUES) {
22126                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22127         }
22128         if (flags & NDR_IN) {
22129                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
22130                 ndr->depth++;
22131                 ndr_print_ptr(ndr, "server", r->in.server);
22132                 ndr->depth++;
22133                 if (r->in.server) {
22134                         ndr_print_string(ndr, "server", r->in.server);
22135                 }
22136                 ndr->depth--;
22137                 ndr_print_ptr(ndr, "environment", r->in.environment);
22138                 ndr->depth++;
22139                 if (r->in.environment) {
22140                         ndr_print_string(ndr, "environment", r->in.environment);
22141                 }
22142                 ndr->depth--;
22143                 ndr_print_uint32(ndr, "level", r->in.level);
22144                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22145                 ndr->depth++;
22146                 if (r->in.buffer) {
22147                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22148                 }
22149                 ndr->depth--;
22150                 ndr_print_uint32(ndr, "offered", r->in.offered);
22151                 ndr->depth--;
22152         }
22153         if (flags & NDR_OUT) {
22154                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
22155                 ndr->depth++;
22156                 ndr_print_ptr(ndr, "count", r->out.count);
22157                 ndr->depth++;
22158                 ndr_print_uint32(ndr, "count", *r->out.count);
22159                 ndr->depth--;
22160                 ndr_print_ptr(ndr, "info", r->out.info);
22161                 ndr->depth++;
22162                 ndr_print_ptr(ndr, "info", *r->out.info);
22163                 ndr->depth++;
22164                 if (*r->out.info) {
22165                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22166                         ndr->depth++;
22167                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22168                                 char *idx_2=NULL;
22169                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22170                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22171                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22172                                         free(idx_2);
22173                                 }
22174                         }
22175                         ndr->depth--;
22176                 }
22177                 ndr->depth--;
22178                 ndr->depth--;
22179                 ndr_print_ptr(ndr, "needed", r->out.needed);
22180                 ndr->depth++;
22181                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22182                 ndr->depth--;
22183                 ndr_print_WERROR(ndr, "result", r->out.result);
22184                 ndr->depth--;
22185         }
22186         ndr->depth--;
22187 }
22188
22189 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
22190 {
22191         if (flags & NDR_IN) {
22192                 if (r->in.handle == NULL) {
22193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22194                 }
22195                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22196                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
22197                 if (r->in.architecture) {
22198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22201                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22202                 }
22203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22205                 if (r->in.buffer) {
22206                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22207                 }
22208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22209         }
22210         if (flags & NDR_OUT) {
22211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22212                 if (r->out.info) {
22213                         {
22214                                 struct ndr_push *_ndr_info;
22215                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22216                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22217                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22218                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22219                         }
22220                 }
22221                 if (r->out.needed == NULL) {
22222                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22223                 }
22224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22225                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22226         }
22227         return NDR_ERR_SUCCESS;
22228 }
22229
22230 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
22231 {
22232         uint32_t _ptr_architecture;
22233         uint32_t size_architecture_1 = 0;
22234         uint32_t length_architecture_1 = 0;
22235         uint32_t _ptr_buffer;
22236         uint32_t _ptr_info;
22237         TALLOC_CTX *_mem_save_handle_0;
22238         TALLOC_CTX *_mem_save_architecture_0;
22239         TALLOC_CTX *_mem_save_buffer_0;
22240         TALLOC_CTX *_mem_save_info_0;
22241         TALLOC_CTX *_mem_save_needed_0;
22242         if (flags & NDR_IN) {
22243                 ZERO_STRUCT(r->out);
22244
22245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22246                         NDR_PULL_ALLOC(ndr, r->in.handle);
22247                 }
22248                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22249                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22250                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
22253                 if (_ptr_architecture) {
22254                         NDR_PULL_ALLOC(ndr, r->in.architecture);
22255                 } else {
22256                         r->in.architecture = NULL;
22257                 }
22258                 if (r->in.architecture) {
22259                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
22260                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
22261                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22262                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22263                         size_architecture_1 = ndr_get_array_size(ndr, &r->in.architecture);
22264                         length_architecture_1 = ndr_get_array_length(ndr, &r->in.architecture);
22265                         if (length_architecture_1 > size_architecture_1) {
22266                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
22267                         }
22268                         NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
22269                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
22270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
22271                 }
22272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22273                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22274                 if (_ptr_buffer) {
22275                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22276                 } else {
22277                         r->in.buffer = NULL;
22278                 }
22279                 if (r->in.buffer) {
22280                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22281                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22282                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22284                 }
22285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22286                 NDR_PULL_ALLOC(ndr, r->out.needed);
22287                 ZERO_STRUCTP(r->out.needed);
22288         }
22289         if (flags & NDR_OUT) {
22290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22291                 if (_ptr_info) {
22292                         NDR_PULL_ALLOC(ndr, r->out.info);
22293                 } else {
22294                         r->out.info = NULL;
22295                 }
22296                 if (r->out.info) {
22297                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22298                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22299                         {
22300                                 struct ndr_pull *_ndr_info;
22301                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22302                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22303                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22304                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22305                         }
22306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22307                 }
22308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22309                         NDR_PULL_ALLOC(ndr, r->out.needed);
22310                 }
22311                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22315                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22316         }
22317         return NDR_ERR_SUCCESS;
22318 }
22319
22320 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
22321 {
22322         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
22323         ndr->depth++;
22324         if (flags & NDR_SET_VALUES) {
22325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22326         }
22327         if (flags & NDR_IN) {
22328                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
22329                 ndr->depth++;
22330                 ndr_print_ptr(ndr, "handle", r->in.handle);
22331                 ndr->depth++;
22332                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22333                 ndr->depth--;
22334                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
22335                 ndr->depth++;
22336                 if (r->in.architecture) {
22337                         ndr_print_string(ndr, "architecture", r->in.architecture);
22338                 }
22339                 ndr->depth--;
22340                 ndr_print_uint32(ndr, "level", r->in.level);
22341                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22342                 ndr->depth++;
22343                 if (r->in.buffer) {
22344                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22345                 }
22346                 ndr->depth--;
22347                 ndr_print_uint32(ndr, "offered", r->in.offered);
22348                 ndr->depth--;
22349         }
22350         if (flags & NDR_OUT) {
22351                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
22352                 ndr->depth++;
22353                 ndr_print_ptr(ndr, "info", r->out.info);
22354                 ndr->depth++;
22355                 if (r->out.info) {
22356                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22357                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
22358                 }
22359                 ndr->depth--;
22360                 ndr_print_ptr(ndr, "needed", r->out.needed);
22361                 ndr->depth++;
22362                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22363                 ndr->depth--;
22364                 ndr_print_WERROR(ndr, "result", r->out.result);
22365                 ndr->depth--;
22366         }
22367         ndr->depth--;
22368 }
22369
22370 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22371 {
22372         if (flags & NDR_IN) {
22373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22374                 if (r->in.server) {
22375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22377                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22378                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22379                 }
22380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22381                 if (r->in.environment) {
22382                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22383                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22384                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22385                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22386                 }
22387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22389                 if (r->in.buffer) {
22390                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22391                 }
22392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22393         }
22394         if (flags & NDR_OUT) {
22395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22396                 if (r->out.info) {
22397                         {
22398                                 struct ndr_push *_ndr_info;
22399                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22400                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22401                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22402                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22403                         }
22404                 }
22405                 if (r->out.needed == NULL) {
22406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22407                 }
22408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22409                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22410         }
22411         return NDR_ERR_SUCCESS;
22412 }
22413
22414 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
22415 {
22416         uint32_t _ptr_server;
22417         uint32_t size_server_1 = 0;
22418         uint32_t length_server_1 = 0;
22419         uint32_t _ptr_environment;
22420         uint32_t size_environment_1 = 0;
22421         uint32_t length_environment_1 = 0;
22422         uint32_t _ptr_buffer;
22423         uint32_t _ptr_info;
22424         TALLOC_CTX *_mem_save_server_0;
22425         TALLOC_CTX *_mem_save_environment_0;
22426         TALLOC_CTX *_mem_save_buffer_0;
22427         TALLOC_CTX *_mem_save_info_0;
22428         TALLOC_CTX *_mem_save_needed_0;
22429         if (flags & NDR_IN) {
22430                 ZERO_STRUCT(r->out);
22431
22432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22433                 if (_ptr_server) {
22434                         NDR_PULL_ALLOC(ndr, r->in.server);
22435                 } else {
22436                         r->in.server = NULL;
22437                 }
22438                 if (r->in.server) {
22439                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22440                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22441                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22442                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22443                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
22444                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
22445                         if (length_server_1 > size_server_1) {
22446                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
22447                         }
22448                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
22449                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
22450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22451                 }
22452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22453                 if (_ptr_environment) {
22454                         NDR_PULL_ALLOC(ndr, r->in.environment);
22455                 } else {
22456                         r->in.environment = NULL;
22457                 }
22458                 if (r->in.environment) {
22459                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22460                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22463                         size_environment_1 = ndr_get_array_size(ndr, &r->in.environment);
22464                         length_environment_1 = ndr_get_array_length(ndr, &r->in.environment);
22465                         if (length_environment_1 > size_environment_1) {
22466                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_environment_1, length_environment_1);
22467                         }
22468                         NDR_CHECK(ndr_check_string_terminator(ndr, length_environment_1, sizeof(uint16_t)));
22469                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, length_environment_1, sizeof(uint16_t), CH_UTF16));
22470                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22471                 }
22472                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22474                 if (_ptr_buffer) {
22475                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22476                 } else {
22477                         r->in.buffer = NULL;
22478                 }
22479                 if (r->in.buffer) {
22480                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22481                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22482                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22484                 }
22485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22486                 NDR_PULL_ALLOC(ndr, r->out.needed);
22487                 ZERO_STRUCTP(r->out.needed);
22488         }
22489         if (flags & NDR_OUT) {
22490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22491                 if (_ptr_info) {
22492                         NDR_PULL_ALLOC(ndr, r->out.info);
22493                 } else {
22494                         r->out.info = NULL;
22495                 }
22496                 if (r->out.info) {
22497                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22498                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22499                         {
22500                                 struct ndr_pull *_ndr_info;
22501                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22502                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22503                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22504                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22505                         }
22506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22507                 }
22508                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22509                         NDR_PULL_ALLOC(ndr, r->out.needed);
22510                 }
22511                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22512                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22514                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22515                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22516         }
22517         return NDR_ERR_SUCCESS;
22518 }
22519
22520 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22521 {
22522         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
22523         ndr->depth++;
22524         if (flags & NDR_SET_VALUES) {
22525                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22526         }
22527         if (flags & NDR_IN) {
22528                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
22529                 ndr->depth++;
22530                 ndr_print_ptr(ndr, "server", r->in.server);
22531                 ndr->depth++;
22532                 if (r->in.server) {
22533                         ndr_print_string(ndr, "server", r->in.server);
22534                 }
22535                 ndr->depth--;
22536                 ndr_print_ptr(ndr, "environment", r->in.environment);
22537                 ndr->depth++;
22538                 if (r->in.environment) {
22539                         ndr_print_string(ndr, "environment", r->in.environment);
22540                 }
22541                 ndr->depth--;
22542                 ndr_print_uint32(ndr, "level", r->in.level);
22543                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22544                 ndr->depth++;
22545                 if (r->in.buffer) {
22546                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22547                 }
22548                 ndr->depth--;
22549                 ndr_print_uint32(ndr, "offered", r->in.offered);
22550                 ndr->depth--;
22551         }
22552         if (flags & NDR_OUT) {
22553                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
22554                 ndr->depth++;
22555                 ndr_print_ptr(ndr, "info", r->out.info);
22556                 ndr->depth++;
22557                 if (r->out.info) {
22558                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22559                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
22560                 }
22561                 ndr->depth--;
22562                 ndr_print_ptr(ndr, "needed", r->out.needed);
22563                 ndr->depth++;
22564                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22565                 ndr->depth--;
22566                 ndr_print_WERROR(ndr, "result", r->out.result);
22567                 ndr->depth--;
22568         }
22569         ndr->depth--;
22570 }
22571
22572 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
22573 {
22574         if (flags & NDR_IN) {
22575                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22576                 if (r->in.server) {
22577                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22578                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22579                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22580                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22581                 }
22582                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22583                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22584                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22585                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22586                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22587                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22588                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22589                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22590         }
22591         if (flags & NDR_OUT) {
22592                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22593         }
22594         return NDR_ERR_SUCCESS;
22595 }
22596
22597 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22598 {
22599         uint32_t _ptr_server;
22600         uint32_t size_server_1 = 0;
22601         uint32_t length_server_1 = 0;
22602         uint32_t size_architecture_0 = 0;
22603         uint32_t length_architecture_0 = 0;
22604         uint32_t size_driver_0 = 0;
22605         uint32_t length_driver_0 = 0;
22606         TALLOC_CTX *_mem_save_server_0;
22607         if (flags & NDR_IN) {
22608                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22609                 if (_ptr_server) {
22610                         NDR_PULL_ALLOC(ndr, r->in.server);
22611                 } else {
22612                         r->in.server = NULL;
22613                 }
22614                 if (r->in.server) {
22615                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22616                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22617                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22618                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22619                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
22620                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
22621                         if (length_server_1 > size_server_1) {
22622                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
22623                         }
22624                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
22625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
22626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22627                 }
22628                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22629                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22630                 size_architecture_0 = ndr_get_array_size(ndr, &r->in.architecture);
22631                 length_architecture_0 = ndr_get_array_length(ndr, &r->in.architecture);
22632                 if (length_architecture_0 > size_architecture_0) {
22633                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_0, length_architecture_0);
22634                 }
22635                 NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_0, sizeof(uint16_t)));
22636                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, length_architecture_0, sizeof(uint16_t), CH_UTF16));
22637                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22638                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22639                 size_driver_0 = ndr_get_array_size(ndr, &r->in.driver);
22640                 length_driver_0 = ndr_get_array_length(ndr, &r->in.driver);
22641                 if (length_driver_0 > size_driver_0) {
22642                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_0, length_driver_0);
22643                 }
22644                 NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_0, sizeof(uint16_t)));
22645                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, length_driver_0, sizeof(uint16_t), CH_UTF16));
22646         }
22647         if (flags & NDR_OUT) {
22648                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22649         }
22650         return NDR_ERR_SUCCESS;
22651 }
22652
22653 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22654 {
22655         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22656         ndr->depth++;
22657         if (flags & NDR_SET_VALUES) {
22658                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22659         }
22660         if (flags & NDR_IN) {
22661                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22662                 ndr->depth++;
22663                 ndr_print_ptr(ndr, "server", r->in.server);
22664                 ndr->depth++;
22665                 if (r->in.server) {
22666                         ndr_print_string(ndr, "server", r->in.server);
22667                 }
22668                 ndr->depth--;
22669                 ndr_print_string(ndr, "architecture", r->in.architecture);
22670                 ndr_print_string(ndr, "driver", r->in.driver);
22671                 ndr->depth--;
22672         }
22673         if (flags & NDR_OUT) {
22674                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22675                 ndr->depth++;
22676                 ndr_print_WERROR(ndr, "result", r->out.result);
22677                 ndr->depth--;
22678         }
22679         ndr->depth--;
22680 }
22681
22682 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22683 {
22684         if (flags & NDR_IN) {
22685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22686                 if (r->in.server) {
22687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22690                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22691                 }
22692                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22693                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22694                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22695                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22696                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22697                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22698                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22699                 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));
22700                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22701                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22702                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22703                 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));
22704         }
22705         if (flags & NDR_OUT) {
22706                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22707         }
22708         return NDR_ERR_SUCCESS;
22709 }
22710
22711 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22712 {
22713         uint32_t _ptr_server;
22714         uint32_t size_server_1 = 0;
22715         uint32_t length_server_1 = 0;
22716         uint32_t size_architecture_0 = 0;
22717         uint32_t length_architecture_0 = 0;
22718         uint32_t size_path_name_0 = 0;
22719         uint32_t length_path_name_0 = 0;
22720         uint32_t size_print_processor_name_0 = 0;
22721         uint32_t length_print_processor_name_0 = 0;
22722         TALLOC_CTX *_mem_save_server_0;
22723         if (flags & NDR_IN) {
22724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22725                 if (_ptr_server) {
22726                         NDR_PULL_ALLOC(ndr, r->in.server);
22727                 } else {
22728                         r->in.server = NULL;
22729                 }
22730                 if (r->in.server) {
22731                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22732                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22733                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22734                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22735                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
22736                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
22737                         if (length_server_1 > size_server_1) {
22738                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
22739                         }
22740                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
22741                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
22742                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22743                 }
22744                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22745                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22746                 size_architecture_0 = ndr_get_array_size(ndr, &r->in.architecture);
22747                 length_architecture_0 = ndr_get_array_length(ndr, &r->in.architecture);
22748                 if (length_architecture_0 > size_architecture_0) {
22749                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_0, length_architecture_0);
22750                 }
22751                 NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_0, sizeof(uint16_t)));
22752                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, length_architecture_0, sizeof(uint16_t), CH_UTF16));
22753                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22754                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22755                 size_path_name_0 = ndr_get_array_size(ndr, &r->in.path_name);
22756                 length_path_name_0 = ndr_get_array_length(ndr, &r->in.path_name);
22757                 if (length_path_name_0 > size_path_name_0) {
22758                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_name_0, length_path_name_0);
22759                 }
22760                 NDR_CHECK(ndr_check_string_terminator(ndr, length_path_name_0, sizeof(uint16_t)));
22761                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path_name, length_path_name_0, sizeof(uint16_t), CH_UTF16));
22762                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22763                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22764                 size_print_processor_name_0 = ndr_get_array_size(ndr, &r->in.print_processor_name);
22765                 length_print_processor_name_0 = ndr_get_array_length(ndr, &r->in.print_processor_name);
22766                 if (length_print_processor_name_0 > size_print_processor_name_0) {
22767                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_print_processor_name_0, length_print_processor_name_0);
22768                 }
22769                 NDR_CHECK(ndr_check_string_terminator(ndr, length_print_processor_name_0, sizeof(uint16_t)));
22770                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.print_processor_name, length_print_processor_name_0, sizeof(uint16_t), CH_UTF16));
22771         }
22772         if (flags & NDR_OUT) {
22773                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22774         }
22775         return NDR_ERR_SUCCESS;
22776 }
22777
22778 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22779 {
22780         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22781         ndr->depth++;
22782         if (flags & NDR_SET_VALUES) {
22783                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22784         }
22785         if (flags & NDR_IN) {
22786                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22787                 ndr->depth++;
22788                 ndr_print_ptr(ndr, "server", r->in.server);
22789                 ndr->depth++;
22790                 if (r->in.server) {
22791                         ndr_print_string(ndr, "server", r->in.server);
22792                 }
22793                 ndr->depth--;
22794                 ndr_print_string(ndr, "architecture", r->in.architecture);
22795                 ndr_print_string(ndr, "path_name", r->in.path_name);
22796                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22797                 ndr->depth--;
22798         }
22799         if (flags & NDR_OUT) {
22800                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22801                 ndr->depth++;
22802                 ndr_print_WERROR(ndr, "result", r->out.result);
22803                 ndr->depth--;
22804         }
22805         ndr->depth--;
22806 }
22807
22808 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22809 {
22810         if (flags & NDR_IN) {
22811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22812                 if (r->in.servername) {
22813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22816                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22817                 }
22818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22819                 if (r->in.environment) {
22820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22821                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22824                 }
22825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22826                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22827                 if (r->in.buffer) {
22828                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22829                 }
22830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22831         }
22832         if (flags & NDR_OUT) {
22833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22834                 if (r->out.info) {
22835                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22836                 }
22837                 if (r->out.needed == NULL) {
22838                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22839                 }
22840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22841                 if (r->out.count == NULL) {
22842                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22843                 }
22844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22845                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22846         }
22847         return NDR_ERR_SUCCESS;
22848 }
22849
22850 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22851 {
22852         uint32_t _ptr_servername;
22853         uint32_t size_servername_1 = 0;
22854         uint32_t length_servername_1 = 0;
22855         uint32_t _ptr_environment;
22856         uint32_t size_environment_1 = 0;
22857         uint32_t length_environment_1 = 0;
22858         uint32_t _ptr_buffer;
22859         uint32_t _ptr_info;
22860         TALLOC_CTX *_mem_save_servername_0;
22861         TALLOC_CTX *_mem_save_environment_0;
22862         TALLOC_CTX *_mem_save_buffer_0;
22863         TALLOC_CTX *_mem_save_info_0;
22864         TALLOC_CTX *_mem_save_needed_0;
22865         TALLOC_CTX *_mem_save_count_0;
22866         if (flags & NDR_IN) {
22867                 ZERO_STRUCT(r->out);
22868
22869                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22870                 if (_ptr_servername) {
22871                         NDR_PULL_ALLOC(ndr, r->in.servername);
22872                 } else {
22873                         r->in.servername = NULL;
22874                 }
22875                 if (r->in.servername) {
22876                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22877                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22878                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22879                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22880                         size_servername_1 = ndr_get_array_size(ndr, &r->in.servername);
22881                         length_servername_1 = ndr_get_array_length(ndr, &r->in.servername);
22882                         if (length_servername_1 > size_servername_1) {
22883                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
22884                         }
22885                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
22886                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
22887                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22888                 }
22889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22890                 if (_ptr_environment) {
22891                         NDR_PULL_ALLOC(ndr, r->in.environment);
22892                 } else {
22893                         r->in.environment = NULL;
22894                 }
22895                 if (r->in.environment) {
22896                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22897                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22898                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22899                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22900                         size_environment_1 = ndr_get_array_size(ndr, &r->in.environment);
22901                         length_environment_1 = ndr_get_array_length(ndr, &r->in.environment);
22902                         if (length_environment_1 > size_environment_1) {
22903                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_environment_1, length_environment_1);
22904                         }
22905                         NDR_CHECK(ndr_check_string_terminator(ndr, length_environment_1, sizeof(uint16_t)));
22906                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, length_environment_1, sizeof(uint16_t), CH_UTF16));
22907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22908                 }
22909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22911                 if (_ptr_buffer) {
22912                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22913                 } else {
22914                         r->in.buffer = NULL;
22915                 }
22916                 if (r->in.buffer) {
22917                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22918                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22919                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22921                 }
22922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22923                 NDR_PULL_ALLOC(ndr, r->out.needed);
22924                 ZERO_STRUCTP(r->out.needed);
22925                 NDR_PULL_ALLOC(ndr, r->out.count);
22926                 ZERO_STRUCTP(r->out.count);
22927         }
22928         if (flags & NDR_OUT) {
22929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22930                 if (_ptr_info) {
22931                         NDR_PULL_ALLOC(ndr, r->out.info);
22932                 } else {
22933                         r->out.info = NULL;
22934                 }
22935                 if (r->out.info) {
22936                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22937                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22938                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22940                 }
22941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22942                         NDR_PULL_ALLOC(ndr, r->out.needed);
22943                 }
22944                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22945                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22948                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22949                         NDR_PULL_ALLOC(ndr, r->out.count);
22950                 }
22951                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22952                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22955                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22956         }
22957         return NDR_ERR_SUCCESS;
22958 }
22959
22960 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22961 {
22962         uint32_t cntr_info_0;
22963         if (flags & NDR_IN) {
22964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22966         }
22967         if (flags & NDR_OUT) {
22968                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22969                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22970                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22971                 }
22972                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22973                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22974                 }
22975         }
22976         return NDR_ERR_SUCCESS;
22977 }
22978
22979 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22980 {
22981         uint32_t size_info_0 = 0;
22982         uint32_t cntr_info_0;
22983         TALLOC_CTX *_mem_save_info_0;
22984         if (flags & NDR_IN) {
22985                 ZERO_STRUCT(r->out);
22986
22987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22989         }
22990         if (flags & NDR_OUT) {
22991                 size_info_0 = r->in.count;
22992                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
22993                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22994                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22995                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
22996                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22997                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22998                 }
22999                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
23000                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23001                 }
23002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23003         }
23004         return NDR_ERR_SUCCESS;
23005 }
23006
23007 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
23008 {
23009         uint32_t cntr_info_2;
23010         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
23011         ndr->depth++;
23012         if (flags & NDR_SET_VALUES) {
23013                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23014         }
23015         if (flags & NDR_IN) {
23016                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
23017                 ndr->depth++;
23018                 ndr_print_ptr(ndr, "servername", r->in.servername);
23019                 ndr->depth++;
23020                 if (r->in.servername) {
23021                         ndr_print_string(ndr, "servername", r->in.servername);
23022                 }
23023                 ndr->depth--;
23024                 ndr_print_ptr(ndr, "environment", r->in.environment);
23025                 ndr->depth++;
23026                 if (r->in.environment) {
23027                         ndr_print_string(ndr, "environment", r->in.environment);
23028                 }
23029                 ndr->depth--;
23030                 ndr_print_uint32(ndr, "level", r->in.level);
23031                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23032                 ndr->depth++;
23033                 if (r->in.buffer) {
23034                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23035                 }
23036                 ndr->depth--;
23037                 ndr_print_uint32(ndr, "offered", r->in.offered);
23038                 ndr->depth--;
23039         }
23040         if (flags & NDR_OUT) {
23041                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
23042                 ndr->depth++;
23043                 ndr_print_ptr(ndr, "count", r->out.count);
23044                 ndr->depth++;
23045                 ndr_print_uint32(ndr, "count", *r->out.count);
23046                 ndr->depth--;
23047                 ndr_print_ptr(ndr, "info", r->out.info);
23048                 ndr->depth++;
23049                 ndr_print_ptr(ndr, "info", *r->out.info);
23050                 ndr->depth++;
23051                 if (*r->out.info) {
23052                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23053                         ndr->depth++;
23054                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23055                                 char *idx_2=NULL;
23056                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23057                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23058                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23059                                         free(idx_2);
23060                                 }
23061                         }
23062                         ndr->depth--;
23063                 }
23064                 ndr->depth--;
23065                 ndr->depth--;
23066                 ndr_print_ptr(ndr, "needed", r->out.needed);
23067                 ndr->depth++;
23068                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23069                 ndr->depth--;
23070                 ndr_print_WERROR(ndr, "result", r->out.result);
23071                 ndr->depth--;
23072         }
23073         ndr->depth--;
23074 }
23075
23076 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
23077 {
23078         if (flags & NDR_IN) {
23079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
23080                 if (r->in.server) {
23081                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
23082                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23083                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
23084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23085                 }
23086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
23087                 if (r->in.environment) {
23088                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
23089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
23091                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23092                 }
23093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23095                 if (r->in.buffer) {
23096                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23097                 }
23098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23099         }
23100         if (flags & NDR_OUT) {
23101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23102                 if (r->out.info) {
23103                         {
23104                                 struct ndr_push *_ndr_info;
23105                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23106                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23107                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
23108                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23109                         }
23110                 }
23111                 if (r->out.needed == NULL) {
23112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23113                 }
23114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23115                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23116         }
23117         return NDR_ERR_SUCCESS;
23118 }
23119
23120 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
23121 {
23122         uint32_t _ptr_server;
23123         uint32_t size_server_1 = 0;
23124         uint32_t length_server_1 = 0;
23125         uint32_t _ptr_environment;
23126         uint32_t size_environment_1 = 0;
23127         uint32_t length_environment_1 = 0;
23128         uint32_t _ptr_buffer;
23129         uint32_t _ptr_info;
23130         TALLOC_CTX *_mem_save_server_0;
23131         TALLOC_CTX *_mem_save_environment_0;
23132         TALLOC_CTX *_mem_save_buffer_0;
23133         TALLOC_CTX *_mem_save_info_0;
23134         TALLOC_CTX *_mem_save_needed_0;
23135         if (flags & NDR_IN) {
23136                 ZERO_STRUCT(r->out);
23137
23138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
23139                 if (_ptr_server) {
23140                         NDR_PULL_ALLOC(ndr, r->in.server);
23141                 } else {
23142                         r->in.server = NULL;
23143                 }
23144                 if (r->in.server) {
23145                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
23146                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
23147                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
23148                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
23149                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
23150                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
23151                         if (length_server_1 > size_server_1) {
23152                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
23153                         }
23154                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
23155                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
23156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
23157                 }
23158                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
23159                 if (_ptr_environment) {
23160                         NDR_PULL_ALLOC(ndr, r->in.environment);
23161                 } else {
23162                         r->in.environment = NULL;
23163                 }
23164                 if (r->in.environment) {
23165                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
23166                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
23167                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
23168                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
23169                         size_environment_1 = ndr_get_array_size(ndr, &r->in.environment);
23170                         length_environment_1 = ndr_get_array_length(ndr, &r->in.environment);
23171                         if (length_environment_1 > size_environment_1) {
23172                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_environment_1, length_environment_1);
23173                         }
23174                         NDR_CHECK(ndr_check_string_terminator(ndr, length_environment_1, sizeof(uint16_t)));
23175                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, length_environment_1, sizeof(uint16_t), CH_UTF16));
23176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
23177                 }
23178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23180                 if (_ptr_buffer) {
23181                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23182                 } else {
23183                         r->in.buffer = NULL;
23184                 }
23185                 if (r->in.buffer) {
23186                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23187                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23188                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23189                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23190                 }
23191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23192                 NDR_PULL_ALLOC(ndr, r->out.needed);
23193                 ZERO_STRUCTP(r->out.needed);
23194         }
23195         if (flags & NDR_OUT) {
23196                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23197                 if (_ptr_info) {
23198                         NDR_PULL_ALLOC(ndr, r->out.info);
23199                 } else {
23200                         r->out.info = NULL;
23201                 }
23202                 if (r->out.info) {
23203                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23204                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23205                         {
23206                                 struct ndr_pull *_ndr_info;
23207                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23208                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23209                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
23210                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23211                         }
23212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23213                 }
23214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23215                         NDR_PULL_ALLOC(ndr, r->out.needed);
23216                 }
23217                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23222         }
23223         return NDR_ERR_SUCCESS;
23224 }
23225
23226 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
23227 {
23228         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
23229         ndr->depth++;
23230         if (flags & NDR_SET_VALUES) {
23231                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23232         }
23233         if (flags & NDR_IN) {
23234                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
23235                 ndr->depth++;
23236                 ndr_print_ptr(ndr, "server", r->in.server);
23237                 ndr->depth++;
23238                 if (r->in.server) {
23239                         ndr_print_string(ndr, "server", r->in.server);
23240                 }
23241                 ndr->depth--;
23242                 ndr_print_ptr(ndr, "environment", r->in.environment);
23243                 ndr->depth++;
23244                 if (r->in.environment) {
23245                         ndr_print_string(ndr, "environment", r->in.environment);
23246                 }
23247                 ndr->depth--;
23248                 ndr_print_uint32(ndr, "level", r->in.level);
23249                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23250                 ndr->depth++;
23251                 if (r->in.buffer) {
23252                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23253                 }
23254                 ndr->depth--;
23255                 ndr_print_uint32(ndr, "offered", r->in.offered);
23256                 ndr->depth--;
23257         }
23258         if (flags & NDR_OUT) {
23259                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
23260                 ndr->depth++;
23261                 ndr_print_ptr(ndr, "info", r->out.info);
23262                 ndr->depth++;
23263                 if (r->out.info) {
23264                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23265                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
23266                 }
23267                 ndr->depth--;
23268                 ndr_print_ptr(ndr, "needed", r->out.needed);
23269                 ndr->depth++;
23270                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23271                 ndr->depth--;
23272                 ndr_print_WERROR(ndr, "result", r->out.result);
23273                 ndr->depth--;
23274         }
23275         ndr->depth--;
23276 }
23277
23278 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
23279 {
23280         if (flags & NDR_IN) {
23281                 if (r->in.handle == NULL) {
23282                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23283                 }
23284                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23286                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23287                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23288         }
23289         if (flags & NDR_OUT) {
23290                 if (r->out.job_id == NULL) {
23291                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23292                 }
23293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
23294                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23295         }
23296         return NDR_ERR_SUCCESS;
23297 }
23298
23299 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
23300 {
23301         TALLOC_CTX *_mem_save_handle_0;
23302         TALLOC_CTX *_mem_save_job_id_0;
23303         if (flags & NDR_IN) {
23304                 ZERO_STRUCT(r->out);
23305
23306                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23307                         NDR_PULL_ALLOC(ndr, r->in.handle);
23308                 }
23309                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23310                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23311                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23312                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23314                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23315                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23316                 NDR_PULL_ALLOC(ndr, r->out.job_id);
23317                 ZERO_STRUCTP(r->out.job_id);
23318         }
23319         if (flags & NDR_OUT) {
23320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23321                         NDR_PULL_ALLOC(ndr, r->out.job_id);
23322                 }
23323                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
23324                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
23325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
23326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
23327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23328         }
23329         return NDR_ERR_SUCCESS;
23330 }
23331
23332 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
23333 {
23334         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
23335         ndr->depth++;
23336         if (flags & NDR_SET_VALUES) {
23337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23338         }
23339         if (flags & NDR_IN) {
23340                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
23341                 ndr->depth++;
23342                 ndr_print_ptr(ndr, "handle", r->in.handle);
23343                 ndr->depth++;
23344                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23345                 ndr->depth--;
23346                 ndr_print_uint32(ndr, "level", r->in.level);
23347                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23348                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
23349                 ndr->depth--;
23350         }
23351         if (flags & NDR_OUT) {
23352                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
23353                 ndr->depth++;
23354                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
23355                 ndr->depth++;
23356                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
23357                 ndr->depth--;
23358                 ndr_print_WERROR(ndr, "result", r->out.result);
23359                 ndr->depth--;
23360         }
23361         ndr->depth--;
23362 }
23363
23364 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
23365 {
23366         if (flags & NDR_IN) {
23367                 if (r->in.handle == NULL) {
23368                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23369                 }
23370                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23371         }
23372         if (flags & NDR_OUT) {
23373                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23374         }
23375         return NDR_ERR_SUCCESS;
23376 }
23377
23378 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
23379 {
23380         TALLOC_CTX *_mem_save_handle_0;
23381         if (flags & NDR_IN) {
23382                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23383                         NDR_PULL_ALLOC(ndr, r->in.handle);
23384                 }
23385                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23386                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23387                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23389         }
23390         if (flags & NDR_OUT) {
23391                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23392         }
23393         return NDR_ERR_SUCCESS;
23394 }
23395
23396 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
23397 {
23398         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
23399         ndr->depth++;
23400         if (flags & NDR_SET_VALUES) {
23401                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23402         }
23403         if (flags & NDR_IN) {
23404                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
23405                 ndr->depth++;
23406                 ndr_print_ptr(ndr, "handle", r->in.handle);
23407                 ndr->depth++;
23408                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23409                 ndr->depth--;
23410                 ndr->depth--;
23411         }
23412         if (flags & NDR_OUT) {
23413                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
23414                 ndr->depth++;
23415                 ndr_print_WERROR(ndr, "result", r->out.result);
23416                 ndr->depth--;
23417         }
23418         ndr->depth--;
23419 }
23420
23421 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
23422 {
23423         if (flags & NDR_IN) {
23424                 if (r->in.handle == NULL) {
23425                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23426                 }
23427                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23428                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
23430         }
23431         if (flags & NDR_OUT) {
23432                 if (r->out.num_written == NULL) {
23433                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23434                 }
23435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
23436                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23437         }
23438         return NDR_ERR_SUCCESS;
23439 }
23440
23441 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
23442 {
23443         TALLOC_CTX *_mem_save_handle_0;
23444         TALLOC_CTX *_mem_save_num_written_0;
23445         if (flags & NDR_IN) {
23446                 ZERO_STRUCT(r->out);
23447
23448                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23449                         NDR_PULL_ALLOC(ndr, r->in.handle);
23450                 }
23451                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23452                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23453                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23455                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
23456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
23457                 NDR_PULL_ALLOC(ndr, r->out.num_written);
23458                 ZERO_STRUCTP(r->out.num_written);
23459         }
23460         if (flags & NDR_OUT) {
23461                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23462                         NDR_PULL_ALLOC(ndr, r->out.num_written);
23463                 }
23464                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
23465                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
23466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
23467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
23468                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23469         }
23470         return NDR_ERR_SUCCESS;
23471 }
23472
23473 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
23474 {
23475         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
23476         ndr->depth++;
23477         if (flags & NDR_SET_VALUES) {
23478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23479         }
23480         if (flags & NDR_IN) {
23481                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
23482                 ndr->depth++;
23483                 ndr_print_ptr(ndr, "handle", r->in.handle);
23484                 ndr->depth++;
23485                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23486                 ndr->depth--;
23487                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
23488                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
23489                 ndr->depth--;
23490         }
23491         if (flags & NDR_OUT) {
23492                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
23493                 ndr->depth++;
23494                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
23495                 ndr->depth++;
23496                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
23497                 ndr->depth--;
23498                 ndr_print_WERROR(ndr, "result", r->out.result);
23499                 ndr->depth--;
23500         }
23501         ndr->depth--;
23502 }
23503
23504 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
23505 {
23506         if (flags & NDR_IN) {
23507                 if (r->in.handle == NULL) {
23508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23509                 }
23510                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23511         }
23512         if (flags & NDR_OUT) {
23513                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23514         }
23515         return NDR_ERR_SUCCESS;
23516 }
23517
23518 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
23519 {
23520         TALLOC_CTX *_mem_save_handle_0;
23521         if (flags & NDR_IN) {
23522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23523                         NDR_PULL_ALLOC(ndr, r->in.handle);
23524                 }
23525                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23529         }
23530         if (flags & NDR_OUT) {
23531                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23532         }
23533         return NDR_ERR_SUCCESS;
23534 }
23535
23536 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
23537 {
23538         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
23539         ndr->depth++;
23540         if (flags & NDR_SET_VALUES) {
23541                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23542         }
23543         if (flags & NDR_IN) {
23544                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
23545                 ndr->depth++;
23546                 ndr_print_ptr(ndr, "handle", r->in.handle);
23547                 ndr->depth++;
23548                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23549                 ndr->depth--;
23550                 ndr->depth--;
23551         }
23552         if (flags & NDR_OUT) {
23553                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
23554                 ndr->depth++;
23555                 ndr_print_WERROR(ndr, "result", r->out.result);
23556                 ndr->depth--;
23557         }
23558         ndr->depth--;
23559 }
23560
23561 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
23562 {
23563         if (flags & NDR_IN) {
23564                 if (r->in.handle == NULL) {
23565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23566                 }
23567                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23568         }
23569         if (flags & NDR_OUT) {
23570                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23571         }
23572         return NDR_ERR_SUCCESS;
23573 }
23574
23575 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
23576 {
23577         TALLOC_CTX *_mem_save_handle_0;
23578         if (flags & NDR_IN) {
23579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23580                         NDR_PULL_ALLOC(ndr, r->in.handle);
23581                 }
23582                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23583                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23584                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23586         }
23587         if (flags & NDR_OUT) {
23588                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23589         }
23590         return NDR_ERR_SUCCESS;
23591 }
23592
23593 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
23594 {
23595         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
23596         ndr->depth++;
23597         if (flags & NDR_SET_VALUES) {
23598                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23599         }
23600         if (flags & NDR_IN) {
23601                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
23602                 ndr->depth++;
23603                 ndr_print_ptr(ndr, "handle", r->in.handle);
23604                 ndr->depth++;
23605                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23606                 ndr->depth--;
23607                 ndr->depth--;
23608         }
23609         if (flags & NDR_OUT) {
23610                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
23611                 ndr->depth++;
23612                 ndr_print_WERROR(ndr, "result", r->out.result);
23613                 ndr->depth--;
23614         }
23615         ndr->depth--;
23616 }
23617
23618 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
23619 {
23620         if (flags & NDR_IN) {
23621                 if (r->in.handle == NULL) {
23622                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23623                 }
23624                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23626         }
23627         if (flags & NDR_OUT) {
23628                 if (r->out.data == NULL) {
23629                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23630                 }
23631                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23632                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23633                 if (r->out._data_size == NULL) {
23634                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23635                 }
23636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23637                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23638         }
23639         return NDR_ERR_SUCCESS;
23640 }
23641
23642 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23643 {
23644         uint32_t size_data_1 = 0;
23645         TALLOC_CTX *_mem_save_handle_0;
23646         TALLOC_CTX *_mem_save__data_size_0;
23647         if (flags & NDR_IN) {
23648                 ZERO_STRUCT(r->out);
23649
23650                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23651                         NDR_PULL_ALLOC(ndr, r->in.handle);
23652                 }
23653                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23654                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23655                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23656                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23658                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23659                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23660                 NDR_PULL_ALLOC(ndr, r->out._data_size);
23661                 ZERO_STRUCTP(r->out._data_size);
23662         }
23663         if (flags & NDR_OUT) {
23664                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23665                 size_data_1 = ndr_get_array_size(ndr, &r->out.data);
23666                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23667                         NDR_PULL_ALLOC_N(ndr, r->out.data, size_data_1);
23668                 }
23669                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, size_data_1));
23670                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23671                         NDR_PULL_ALLOC(ndr, r->out._data_size);
23672                 }
23673                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23674                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23676                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23677                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23678                 if (r->out.data) {
23679                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23680                 }
23681         }
23682         return NDR_ERR_SUCCESS;
23683 }
23684
23685 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23686 {
23687         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23688         ndr->depth++;
23689         if (flags & NDR_SET_VALUES) {
23690                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23691         }
23692         if (flags & NDR_IN) {
23693                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23694                 ndr->depth++;
23695                 ndr_print_ptr(ndr, "handle", r->in.handle);
23696                 ndr->depth++;
23697                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23698                 ndr->depth--;
23699                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
23700                 ndr->depth--;
23701         }
23702         if (flags & NDR_OUT) {
23703                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23704                 ndr->depth++;
23705                 ndr_print_ptr(ndr, "data", r->out.data);
23706                 ndr->depth++;
23707                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23708                 ndr->depth--;
23709                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23710                 ndr->depth++;
23711                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23712                 ndr->depth--;
23713                 ndr_print_WERROR(ndr, "result", r->out.result);
23714                 ndr->depth--;
23715         }
23716         ndr->depth--;
23717 }
23718
23719 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23720 {
23721         if (flags & NDR_IN) {
23722                 if (r->in.handle == NULL) {
23723                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23724                 }
23725                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23726         }
23727         if (flags & NDR_OUT) {
23728                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23729         }
23730         return NDR_ERR_SUCCESS;
23731 }
23732
23733 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23734 {
23735         TALLOC_CTX *_mem_save_handle_0;
23736         if (flags & NDR_IN) {
23737                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23738                         NDR_PULL_ALLOC(ndr, r->in.handle);
23739                 }
23740                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23741                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23742                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23744         }
23745         if (flags & NDR_OUT) {
23746                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23747         }
23748         return NDR_ERR_SUCCESS;
23749 }
23750
23751 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23752 {
23753         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23754         ndr->depth++;
23755         if (flags & NDR_SET_VALUES) {
23756                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23757         }
23758         if (flags & NDR_IN) {
23759                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23760                 ndr->depth++;
23761                 ndr_print_ptr(ndr, "handle", r->in.handle);
23762                 ndr->depth++;
23763                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23764                 ndr->depth--;
23765                 ndr->depth--;
23766         }
23767         if (flags & NDR_OUT) {
23768                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23769                 ndr->depth++;
23770                 ndr_print_WERROR(ndr, "result", r->out.result);
23771                 ndr->depth--;
23772         }
23773         ndr->depth--;
23774 }
23775
23776 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23777 {
23778         if (flags & NDR_IN) {
23779                 if (r->in.handle == NULL) {
23780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23781                 }
23782                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23785                 if (r->in.buffer) {
23786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23787                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
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.buffer));
23793                 if (r->out.buffer) {
23794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23795                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23796                 }
23797                 if (r->out.needed == NULL) {
23798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23799                 }
23800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23801                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23802         }
23803         return NDR_ERR_SUCCESS;
23804 }
23805
23806 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23807 {
23808         uint32_t _ptr_buffer;
23809         uint32_t size_buffer_1 = 0;
23810         TALLOC_CTX *_mem_save_handle_0;
23811         TALLOC_CTX *_mem_save_buffer_0;
23812         TALLOC_CTX *_mem_save_needed_0;
23813         if (flags & NDR_IN) {
23814                 ZERO_STRUCT(r->out);
23815
23816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23817                         NDR_PULL_ALLOC(ndr, r->in.handle);
23818                 }
23819                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23820                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23821                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23825                 if (_ptr_buffer) {
23826                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23827                 } else {
23828                         r->in.buffer = NULL;
23829                 }
23830                 if (r->in.buffer) {
23831                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23832                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23833                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23834                         size_buffer_1 = ndr_get_array_size(ndr, &r->in.buffer);
23835                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, size_buffer_1);
23836                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, size_buffer_1));
23837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23838                 }
23839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23840                 NDR_PULL_ALLOC(ndr, r->out.needed);
23841                 ZERO_STRUCTP(r->out.needed);
23842                 if (r->in.buffer) {
23843                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23844                 }
23845         }
23846         if (flags & NDR_OUT) {
23847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23848                 if (_ptr_buffer) {
23849                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23850                 } else {
23851                         r->out.buffer = NULL;
23852                 }
23853                 if (r->out.buffer) {
23854                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23855                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23856                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23857                         size_buffer_1 = ndr_get_array_size(ndr, &r->out.buffer);
23858                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_1);
23859                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, size_buffer_1));
23860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23861                 }
23862                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23863                         NDR_PULL_ALLOC(ndr, r->out.needed);
23864                 }
23865                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23866                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23868                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23869                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23870                 if (r->out.buffer) {
23871                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23872                 }
23873         }
23874         return NDR_ERR_SUCCESS;
23875 }
23876
23877 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23878 {
23879         ndr_print_struct(ndr, name, "spoolss_AddJob");
23880         ndr->depth++;
23881         if (flags & NDR_SET_VALUES) {
23882                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23883         }
23884         if (flags & NDR_IN) {
23885                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23886                 ndr->depth++;
23887                 ndr_print_ptr(ndr, "handle", r->in.handle);
23888                 ndr->depth++;
23889                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23890                 ndr->depth--;
23891                 ndr_print_uint32(ndr, "level", r->in.level);
23892                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23893                 ndr->depth++;
23894                 if (r->in.buffer) {
23895                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23896                 }
23897                 ndr->depth--;
23898                 ndr_print_uint32(ndr, "offered", r->in.offered);
23899                 ndr->depth--;
23900         }
23901         if (flags & NDR_OUT) {
23902                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23903                 ndr->depth++;
23904                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23905                 ndr->depth++;
23906                 if (r->out.buffer) {
23907                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23908                 }
23909                 ndr->depth--;
23910                 ndr_print_ptr(ndr, "needed", r->out.needed);
23911                 ndr->depth++;
23912                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23913                 ndr->depth--;
23914                 ndr_print_WERROR(ndr, "result", r->out.result);
23915                 ndr->depth--;
23916         }
23917         ndr->depth--;
23918 }
23919
23920 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23921 {
23922         if (flags & NDR_IN) {
23923                 if (r->in.handle == NULL) {
23924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23925                 }
23926                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23928         }
23929         if (flags & NDR_OUT) {
23930                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23931         }
23932         return NDR_ERR_SUCCESS;
23933 }
23934
23935 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23936 {
23937         TALLOC_CTX *_mem_save_handle_0;
23938         if (flags & NDR_IN) {
23939                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23940                         NDR_PULL_ALLOC(ndr, r->in.handle);
23941                 }
23942                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23943                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23944                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23945                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23947         }
23948         if (flags & NDR_OUT) {
23949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23950         }
23951         return NDR_ERR_SUCCESS;
23952 }
23953
23954 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23955 {
23956         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23957         ndr->depth++;
23958         if (flags & NDR_SET_VALUES) {
23959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23960         }
23961         if (flags & NDR_IN) {
23962                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23963                 ndr->depth++;
23964                 ndr_print_ptr(ndr, "handle", r->in.handle);
23965                 ndr->depth++;
23966                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23967                 ndr->depth--;
23968                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
23969                 ndr->depth--;
23970         }
23971         if (flags & NDR_OUT) {
23972                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23973                 ndr->depth++;
23974                 ndr_print_WERROR(ndr, "result", r->out.result);
23975                 ndr->depth--;
23976         }
23977         ndr->depth--;
23978 }
23979
23980 static enum ndr_err_code ndr_push_spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterData *r)
23981 {
23982         if (flags & NDR_IN) {
23983                 if (r->in.handle == NULL) {
23984                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23985                 }
23986                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23987                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23988                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23989                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23990                 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));
23991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23992         }
23993         if (flags & NDR_OUT) {
23994                 if (r->out.type == NULL) {
23995                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23996                 }
23997                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23998                 if (r->out.data == NULL) {
23999                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24000                 }
24001                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
24002                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.offered));
24003                 if (r->out.needed == NULL) {
24004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24005                 }
24006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24007                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24008         }
24009         return NDR_ERR_SUCCESS;
24010 }
24011
24012 static enum ndr_err_code ndr_pull_spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterData *r)
24013 {
24014         uint32_t size_value_name_0 = 0;
24015         uint32_t length_value_name_0 = 0;
24016         uint32_t size_data_1 = 0;
24017         TALLOC_CTX *_mem_save_handle_0;
24018         TALLOC_CTX *_mem_save_type_0;
24019         TALLOC_CTX *_mem_save_needed_0;
24020         if (flags & NDR_IN) {
24021                 ZERO_STRUCT(r->out);
24022
24023                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24024                         NDR_PULL_ALLOC(ndr, r->in.handle);
24025                 }
24026                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24027                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24028                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24030                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
24031                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24032                 size_value_name_0 = ndr_get_array_size(ndr, &r->in.value_name);
24033                 length_value_name_0 = ndr_get_array_length(ndr, &r->in.value_name);
24034                 if (length_value_name_0 > size_value_name_0) {
24035                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_value_name_0, length_value_name_0);
24036                 }
24037                 NDR_CHECK(ndr_check_string_terminator(ndr, length_value_name_0, sizeof(uint16_t)));
24038                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, length_value_name_0, sizeof(uint16_t), CH_UTF16));
24039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24040                 NDR_PULL_ALLOC(ndr, r->out.type);
24041                 ZERO_STRUCTP(r->out.type);
24042                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.offered);
24043                 memset(r->out.data, 0, (r->in.offered) * sizeof(*r->out.data));
24044                 NDR_PULL_ALLOC(ndr, r->out.needed);
24045                 ZERO_STRUCTP(r->out.needed);
24046         }
24047         if (flags & NDR_OUT) {
24048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24049                         NDR_PULL_ALLOC(ndr, r->out.type);
24050                 }
24051                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24052                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
24053                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
24054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
24055                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
24056                 size_data_1 = ndr_get_array_size(ndr, &r->out.data);
24057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24058                         NDR_PULL_ALLOC_N(ndr, r->out.data, size_data_1);
24059                 }
24060                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, size_data_1));
24061                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24062                         NDR_PULL_ALLOC(ndr, r->out.needed);
24063                 }
24064                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24065                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24067                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24068                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24069                 if (r->out.data) {
24070                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.offered));
24071                 }
24072         }
24073         return NDR_ERR_SUCCESS;
24074 }
24075
24076 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
24077 {
24078         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
24079         ndr->depth++;
24080         if (flags & NDR_SET_VALUES) {
24081                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24082         }
24083         if (flags & NDR_IN) {
24084                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
24085                 ndr->depth++;
24086                 ndr_print_ptr(ndr, "handle", r->in.handle);
24087                 ndr->depth++;
24088                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24089                 ndr->depth--;
24090                 ndr_print_string(ndr, "value_name", r->in.value_name);
24091                 ndr_print_uint32(ndr, "offered", r->in.offered);
24092                 ndr->depth--;
24093         }
24094         if (flags & NDR_OUT) {
24095                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
24096                 ndr->depth++;
24097                 ndr_print_ptr(ndr, "type", r->out.type);
24098                 ndr->depth++;
24099                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
24100                 ndr->depth--;
24101                 ndr_print_ptr(ndr, "data", r->out.data);
24102                 ndr->depth++;
24103                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.offered);
24104                 ndr->depth--;
24105                 ndr_print_ptr(ndr, "needed", r->out.needed);
24106                 ndr->depth++;
24107                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24108                 ndr->depth--;
24109                 ndr_print_WERROR(ndr, "result", r->out.result);
24110                 ndr->depth--;
24111         }
24112         ndr->depth--;
24113 }
24114
24115 static enum ndr_err_code ndr_push_spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterData *r)
24116 {
24117         if (flags & NDR_IN) {
24118                 if (r->in.handle == NULL) {
24119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24120                 }
24121                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24122                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24123                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24124                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24125                 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));
24126                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24127                 if (r->in.data == NULL) {
24128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24129                 }
24130                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
24131                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.offered));
24132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24133         }
24134         if (flags & NDR_OUT) {
24135                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24136         }
24137         return NDR_ERR_SUCCESS;
24138 }
24139
24140 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
24141 {
24142         uint32_t size_value_name_0 = 0;
24143         uint32_t length_value_name_0 = 0;
24144         uint32_t size_data_1 = 0;
24145         TALLOC_CTX *_mem_save_handle_0;
24146         if (flags & NDR_IN) {
24147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24148                         NDR_PULL_ALLOC(ndr, r->in.handle);
24149                 }
24150                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24151                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24152                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24154                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
24155                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24156                 size_value_name_0 = ndr_get_array_size(ndr, &r->in.value_name);
24157                 length_value_name_0 = ndr_get_array_length(ndr, &r->in.value_name);
24158                 if (length_value_name_0 > size_value_name_0) {
24159                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_value_name_0, length_value_name_0);
24160                 }
24161                 NDR_CHECK(ndr_check_string_terminator(ndr, length_value_name_0, sizeof(uint16_t)));
24162                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, length_value_name_0, sizeof(uint16_t), CH_UTF16));
24163                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24164                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
24165                 size_data_1 = ndr_get_array_size(ndr, &r->in.data);
24166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24167                         NDR_PULL_ALLOC_N(ndr, r->in.data, size_data_1);
24168                 }
24169                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, size_data_1));
24170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24171                 if (r->in.data) {
24172                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.offered));
24173                 }
24174         }
24175         if (flags & NDR_OUT) {
24176                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24177         }
24178         return NDR_ERR_SUCCESS;
24179 }
24180
24181 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
24182 {
24183         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
24184         ndr->depth++;
24185         if (flags & NDR_SET_VALUES) {
24186                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24187         }
24188         if (flags & NDR_IN) {
24189                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
24190                 ndr->depth++;
24191                 ndr_print_ptr(ndr, "handle", r->in.handle);
24192                 ndr->depth++;
24193                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24194                 ndr->depth--;
24195                 ndr_print_string(ndr, "value_name", r->in.value_name);
24196                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24197                 ndr_print_ptr(ndr, "data", r->in.data);
24198                 ndr->depth++;
24199                 ndr_print_array_uint8(ndr, "data", r->in.data, r->in.offered);
24200                 ndr->depth--;
24201                 ndr_print_uint32(ndr, "offered", r->in.offered);
24202                 ndr->depth--;
24203         }
24204         if (flags & NDR_OUT) {
24205                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
24206                 ndr->depth++;
24207                 ndr_print_WERROR(ndr, "result", r->out.result);
24208                 ndr->depth--;
24209         }
24210         ndr->depth--;
24211 }
24212
24213 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
24214 {
24215         if (flags & NDR_IN) {
24216         }
24217         if (flags & NDR_OUT) {
24218                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24219         }
24220         return NDR_ERR_SUCCESS;
24221 }
24222
24223 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
24224 {
24225         if (flags & NDR_IN) {
24226         }
24227         if (flags & NDR_OUT) {
24228                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24229         }
24230         return NDR_ERR_SUCCESS;
24231 }
24232
24233 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
24234 {
24235         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
24236         ndr->depth++;
24237         if (flags & NDR_SET_VALUES) {
24238                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24239         }
24240         if (flags & NDR_IN) {
24241                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
24242                 ndr->depth++;
24243                 ndr->depth--;
24244         }
24245         if (flags & NDR_OUT) {
24246                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
24247                 ndr->depth++;
24248                 ndr_print_WERROR(ndr, "result", r->out.result);
24249                 ndr->depth--;
24250         }
24251         ndr->depth--;
24252 }
24253
24254 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
24255 {
24256         if (flags & NDR_IN) {
24257                 if (r->in.handle == NULL) {
24258                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24259                 }
24260                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24261         }
24262         if (flags & NDR_OUT) {
24263                 if (r->out.handle == NULL) {
24264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24265                 }
24266                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24267                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24268         }
24269         return NDR_ERR_SUCCESS;
24270 }
24271
24272 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
24273 {
24274         TALLOC_CTX *_mem_save_handle_0;
24275         if (flags & NDR_IN) {
24276                 ZERO_STRUCT(r->out);
24277
24278                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24279                         NDR_PULL_ALLOC(ndr, r->in.handle);
24280                 }
24281                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24282                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24283                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24284                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24285                 NDR_PULL_ALLOC(ndr, r->out.handle);
24286                 *r->out.handle = *r->in.handle;
24287         }
24288         if (flags & NDR_OUT) {
24289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24290                         NDR_PULL_ALLOC(ndr, r->out.handle);
24291                 }
24292                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24293                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24294                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24296                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24297         }
24298         return NDR_ERR_SUCCESS;
24299 }
24300
24301 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
24302 {
24303         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
24304         ndr->depth++;
24305         if (flags & NDR_SET_VALUES) {
24306                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24307         }
24308         if (flags & NDR_IN) {
24309                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
24310                 ndr->depth++;
24311                 ndr_print_ptr(ndr, "handle", r->in.handle);
24312                 ndr->depth++;
24313                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24314                 ndr->depth--;
24315                 ndr->depth--;
24316         }
24317         if (flags & NDR_OUT) {
24318                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
24319                 ndr->depth++;
24320                 ndr_print_ptr(ndr, "handle", r->out.handle);
24321                 ndr->depth++;
24322                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24323                 ndr->depth--;
24324                 ndr_print_WERROR(ndr, "result", r->out.result);
24325                 ndr->depth--;
24326         }
24327         ndr->depth--;
24328 }
24329
24330 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
24331 {
24332         if (flags & NDR_IN) {
24333                 if (r->in.handle == NULL) {
24334                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24335                 }
24336                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24338                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24339                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24340         }
24341         if (flags & NDR_OUT) {
24342                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24343         }
24344         return NDR_ERR_SUCCESS;
24345 }
24346
24347 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
24348 {
24349         TALLOC_CTX *_mem_save_handle_0;
24350         if (flags & NDR_IN) {
24351                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24352                         NDR_PULL_ALLOC(ndr, r->in.handle);
24353                 }
24354                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24355                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24356                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24357                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24359                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24360                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24361         }
24362         if (flags & NDR_OUT) {
24363                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24364         }
24365         return NDR_ERR_SUCCESS;
24366 }
24367
24368 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
24369 {
24370         ndr_print_struct(ndr, name, "spoolss_AddForm");
24371         ndr->depth++;
24372         if (flags & NDR_SET_VALUES) {
24373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24374         }
24375         if (flags & NDR_IN) {
24376                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
24377                 ndr->depth++;
24378                 ndr_print_ptr(ndr, "handle", r->in.handle);
24379                 ndr->depth++;
24380                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24381                 ndr->depth--;
24382                 ndr_print_uint32(ndr, "level", r->in.level);
24383                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24384                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24385                 ndr->depth--;
24386         }
24387         if (flags & NDR_OUT) {
24388                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
24389                 ndr->depth++;
24390                 ndr_print_WERROR(ndr, "result", r->out.result);
24391                 ndr->depth--;
24392         }
24393         ndr->depth--;
24394 }
24395
24396 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
24397 {
24398         if (flags & NDR_IN) {
24399                 if (r->in.handle == NULL) {
24400                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24401                 }
24402                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24403                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24404                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24405                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24406                 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));
24407         }
24408         if (flags & NDR_OUT) {
24409                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24410         }
24411         return NDR_ERR_SUCCESS;
24412 }
24413
24414 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
24415 {
24416         uint32_t size_form_name_0 = 0;
24417         uint32_t length_form_name_0 = 0;
24418         TALLOC_CTX *_mem_save_handle_0;
24419         if (flags & NDR_IN) {
24420                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24421                         NDR_PULL_ALLOC(ndr, r->in.handle);
24422                 }
24423                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24424                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24425                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24426                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24427                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24428                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24429                 size_form_name_0 = ndr_get_array_size(ndr, &r->in.form_name);
24430                 length_form_name_0 = ndr_get_array_length(ndr, &r->in.form_name);
24431                 if (length_form_name_0 > size_form_name_0) {
24432                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_form_name_0, length_form_name_0);
24433                 }
24434                 NDR_CHECK(ndr_check_string_terminator(ndr, length_form_name_0, sizeof(uint16_t)));
24435                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, length_form_name_0, sizeof(uint16_t), CH_UTF16));
24436         }
24437         if (flags & NDR_OUT) {
24438                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24439         }
24440         return NDR_ERR_SUCCESS;
24441 }
24442
24443 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
24444 {
24445         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
24446         ndr->depth++;
24447         if (flags & NDR_SET_VALUES) {
24448                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24449         }
24450         if (flags & NDR_IN) {
24451                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
24452                 ndr->depth++;
24453                 ndr_print_ptr(ndr, "handle", r->in.handle);
24454                 ndr->depth++;
24455                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24456                 ndr->depth--;
24457                 ndr_print_string(ndr, "form_name", r->in.form_name);
24458                 ndr->depth--;
24459         }
24460         if (flags & NDR_OUT) {
24461                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
24462                 ndr->depth++;
24463                 ndr_print_WERROR(ndr, "result", r->out.result);
24464                 ndr->depth--;
24465         }
24466         ndr->depth--;
24467 }
24468
24469 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
24470 {
24471         if (flags & NDR_IN) {
24472                 if (r->in.handle == NULL) {
24473                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24474                 }
24475                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24476                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24477                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24478                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24479                 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));
24480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24482                 if (r->in.buffer) {
24483                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24484                 }
24485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24486         }
24487         if (flags & NDR_OUT) {
24488                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24489                 if (r->out.info) {
24490                         {
24491                                 struct ndr_push *_ndr_info;
24492                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24493                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24494                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24495                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24496                         }
24497                 }
24498                 if (r->out.needed == NULL) {
24499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24500                 }
24501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24502                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24503         }
24504         return NDR_ERR_SUCCESS;
24505 }
24506
24507 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
24508 {
24509         uint32_t size_form_name_0 = 0;
24510         uint32_t length_form_name_0 = 0;
24511         uint32_t _ptr_buffer;
24512         uint32_t _ptr_info;
24513         TALLOC_CTX *_mem_save_handle_0;
24514         TALLOC_CTX *_mem_save_buffer_0;
24515         TALLOC_CTX *_mem_save_info_0;
24516         TALLOC_CTX *_mem_save_needed_0;
24517         if (flags & NDR_IN) {
24518                 ZERO_STRUCT(r->out);
24519
24520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24521                         NDR_PULL_ALLOC(ndr, r->in.handle);
24522                 }
24523                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24524                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24525                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24527                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24528                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24529                 size_form_name_0 = ndr_get_array_size(ndr, &r->in.form_name);
24530                 length_form_name_0 = ndr_get_array_length(ndr, &r->in.form_name);
24531                 if (length_form_name_0 > size_form_name_0) {
24532                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_form_name_0, length_form_name_0);
24533                 }
24534                 NDR_CHECK(ndr_check_string_terminator(ndr, length_form_name_0, sizeof(uint16_t)));
24535                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, length_form_name_0, sizeof(uint16_t), CH_UTF16));
24536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24538                 if (_ptr_buffer) {
24539                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24540                 } else {
24541                         r->in.buffer = NULL;
24542                 }
24543                 if (r->in.buffer) {
24544                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24545                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24546                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24548                 }
24549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24550                 NDR_PULL_ALLOC(ndr, r->out.needed);
24551                 ZERO_STRUCTP(r->out.needed);
24552         }
24553         if (flags & NDR_OUT) {
24554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24555                 if (_ptr_info) {
24556                         NDR_PULL_ALLOC(ndr, r->out.info);
24557                 } else {
24558                         r->out.info = NULL;
24559                 }
24560                 if (r->out.info) {
24561                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24562                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24563                         {
24564                                 struct ndr_pull *_ndr_info;
24565                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24566                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24567                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24568                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24569                         }
24570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24571                 }
24572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24573                         NDR_PULL_ALLOC(ndr, r->out.needed);
24574                 }
24575                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24576                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24579                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24580         }
24581         return NDR_ERR_SUCCESS;
24582 }
24583
24584 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
24585 {
24586         ndr_print_struct(ndr, name, "spoolss_GetForm");
24587         ndr->depth++;
24588         if (flags & NDR_SET_VALUES) {
24589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24590         }
24591         if (flags & NDR_IN) {
24592                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
24593                 ndr->depth++;
24594                 ndr_print_ptr(ndr, "handle", r->in.handle);
24595                 ndr->depth++;
24596                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24597                 ndr->depth--;
24598                 ndr_print_string(ndr, "form_name", r->in.form_name);
24599                 ndr_print_uint32(ndr, "level", r->in.level);
24600                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24601                 ndr->depth++;
24602                 if (r->in.buffer) {
24603                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24604                 }
24605                 ndr->depth--;
24606                 ndr_print_uint32(ndr, "offered", r->in.offered);
24607                 ndr->depth--;
24608         }
24609         if (flags & NDR_OUT) {
24610                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
24611                 ndr->depth++;
24612                 ndr_print_ptr(ndr, "info", r->out.info);
24613                 ndr->depth++;
24614                 if (r->out.info) {
24615                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24616                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24617                 }
24618                 ndr->depth--;
24619                 ndr_print_ptr(ndr, "needed", r->out.needed);
24620                 ndr->depth++;
24621                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24622                 ndr->depth--;
24623                 ndr_print_WERROR(ndr, "result", r->out.result);
24624                 ndr->depth--;
24625         }
24626         ndr->depth--;
24627 }
24628
24629 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24630 {
24631         if (flags & NDR_IN) {
24632                 if (r->in.handle == NULL) {
24633                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24634                 }
24635                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24636                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24637                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24638                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24639                 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));
24640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24641                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24642                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24643         }
24644         if (flags & NDR_OUT) {
24645                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24646         }
24647         return NDR_ERR_SUCCESS;
24648 }
24649
24650 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24651 {
24652         uint32_t size_form_name_0 = 0;
24653         uint32_t length_form_name_0 = 0;
24654         TALLOC_CTX *_mem_save_handle_0;
24655         if (flags & NDR_IN) {
24656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24657                         NDR_PULL_ALLOC(ndr, r->in.handle);
24658                 }
24659                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24661                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24663                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24664                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24665                 size_form_name_0 = ndr_get_array_size(ndr, &r->in.form_name);
24666                 length_form_name_0 = ndr_get_array_length(ndr, &r->in.form_name);
24667                 if (length_form_name_0 > size_form_name_0) {
24668                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_form_name_0, length_form_name_0);
24669                 }
24670                 NDR_CHECK(ndr_check_string_terminator(ndr, length_form_name_0, sizeof(uint16_t)));
24671                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, length_form_name_0, sizeof(uint16_t), CH_UTF16));
24672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24673                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24674                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24675         }
24676         if (flags & NDR_OUT) {
24677                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24678         }
24679         return NDR_ERR_SUCCESS;
24680 }
24681
24682 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24683 {
24684         ndr_print_struct(ndr, name, "spoolss_SetForm");
24685         ndr->depth++;
24686         if (flags & NDR_SET_VALUES) {
24687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24688         }
24689         if (flags & NDR_IN) {
24690                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
24691                 ndr->depth++;
24692                 ndr_print_ptr(ndr, "handle", r->in.handle);
24693                 ndr->depth++;
24694                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24695                 ndr->depth--;
24696                 ndr_print_string(ndr, "form_name", r->in.form_name);
24697                 ndr_print_uint32(ndr, "level", r->in.level);
24698                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24699                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24700                 ndr->depth--;
24701         }
24702         if (flags & NDR_OUT) {
24703                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24704                 ndr->depth++;
24705                 ndr_print_WERROR(ndr, "result", r->out.result);
24706                 ndr->depth--;
24707         }
24708         ndr->depth--;
24709 }
24710
24711 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24712 {
24713         if (flags & NDR_IN) {
24714                 if (r->in.handle == NULL) {
24715                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24716                 }
24717                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24720                 if (r->in.buffer) {
24721                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24722                 }
24723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24724         }
24725         if (flags & NDR_OUT) {
24726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24727                 if (r->out.info) {
24728                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24729                 }
24730                 if (r->out.needed == NULL) {
24731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24732                 }
24733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24734                 if (r->out.count == NULL) {
24735                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24736                 }
24737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24738                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24739         }
24740         return NDR_ERR_SUCCESS;
24741 }
24742
24743 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24744 {
24745         uint32_t _ptr_buffer;
24746         uint32_t _ptr_info;
24747         TALLOC_CTX *_mem_save_handle_0;
24748         TALLOC_CTX *_mem_save_buffer_0;
24749         TALLOC_CTX *_mem_save_info_0;
24750         TALLOC_CTX *_mem_save_needed_0;
24751         TALLOC_CTX *_mem_save_count_0;
24752         if (flags & NDR_IN) {
24753                 ZERO_STRUCT(r->out);
24754
24755                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24756                         NDR_PULL_ALLOC(ndr, r->in.handle);
24757                 }
24758                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24759                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24760                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24764                 if (_ptr_buffer) {
24765                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24766                 } else {
24767                         r->in.buffer = NULL;
24768                 }
24769                 if (r->in.buffer) {
24770                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24771                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24772                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24774                 }
24775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24776                 NDR_PULL_ALLOC(ndr, r->out.needed);
24777                 ZERO_STRUCTP(r->out.needed);
24778                 NDR_PULL_ALLOC(ndr, r->out.count);
24779                 ZERO_STRUCTP(r->out.count);
24780         }
24781         if (flags & NDR_OUT) {
24782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24783                 if (_ptr_info) {
24784                         NDR_PULL_ALLOC(ndr, r->out.info);
24785                 } else {
24786                         r->out.info = NULL;
24787                 }
24788                 if (r->out.info) {
24789                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24790                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24791                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24793                 }
24794                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24795                         NDR_PULL_ALLOC(ndr, r->out.needed);
24796                 }
24797                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24798                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24800                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24801                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24802                         NDR_PULL_ALLOC(ndr, r->out.count);
24803                 }
24804                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24805                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24807                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24808                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24809         }
24810         return NDR_ERR_SUCCESS;
24811 }
24812
24813 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24814 {
24815         uint32_t cntr_info_0;
24816         if (flags & NDR_IN) {
24817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24819         }
24820         if (flags & NDR_OUT) {
24821                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24822                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24823                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24824                 }
24825                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24826                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24827                 }
24828         }
24829         return NDR_ERR_SUCCESS;
24830 }
24831
24832 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24833 {
24834         uint32_t size_info_0 = 0;
24835         uint32_t cntr_info_0;
24836         TALLOC_CTX *_mem_save_info_0;
24837         if (flags & NDR_IN) {
24838                 ZERO_STRUCT(r->out);
24839
24840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24842         }
24843         if (flags & NDR_OUT) {
24844                 size_info_0 = r->in.count;
24845                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
24846                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24848                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
24849                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24850                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24851                 }
24852                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
24853                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24854                 }
24855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24856         }
24857         return NDR_ERR_SUCCESS;
24858 }
24859
24860 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24861 {
24862         uint32_t cntr_info_2;
24863         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24864         ndr->depth++;
24865         if (flags & NDR_SET_VALUES) {
24866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24867         }
24868         if (flags & NDR_IN) {
24869                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24870                 ndr->depth++;
24871                 ndr_print_ptr(ndr, "handle", r->in.handle);
24872                 ndr->depth++;
24873                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24874                 ndr->depth--;
24875                 ndr_print_uint32(ndr, "level", r->in.level);
24876                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24877                 ndr->depth++;
24878                 if (r->in.buffer) {
24879                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24880                 }
24881                 ndr->depth--;
24882                 ndr_print_uint32(ndr, "offered", r->in.offered);
24883                 ndr->depth--;
24884         }
24885         if (flags & NDR_OUT) {
24886                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24887                 ndr->depth++;
24888                 ndr_print_ptr(ndr, "count", r->out.count);
24889                 ndr->depth++;
24890                 ndr_print_uint32(ndr, "count", *r->out.count);
24891                 ndr->depth--;
24892                 ndr_print_ptr(ndr, "info", r->out.info);
24893                 ndr->depth++;
24894                 ndr_print_ptr(ndr, "info", *r->out.info);
24895                 ndr->depth++;
24896                 if (*r->out.info) {
24897                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24898                         ndr->depth++;
24899                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24900                                 char *idx_2=NULL;
24901                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24902                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24903                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24904                                         free(idx_2);
24905                                 }
24906                         }
24907                         ndr->depth--;
24908                 }
24909                 ndr->depth--;
24910                 ndr->depth--;
24911                 ndr_print_ptr(ndr, "needed", r->out.needed);
24912                 ndr->depth++;
24913                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24914                 ndr->depth--;
24915                 ndr_print_WERROR(ndr, "result", r->out.result);
24916                 ndr->depth--;
24917         }
24918         ndr->depth--;
24919 }
24920
24921 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24922 {
24923         if (flags & NDR_IN) {
24924                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24925                 if (r->in.servername) {
24926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24929                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24930                 }
24931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24933                 if (r->in.buffer) {
24934                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24935                 }
24936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24937         }
24938         if (flags & NDR_OUT) {
24939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24940                 if (r->out.info) {
24941                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24942                 }
24943                 if (r->out.needed == NULL) {
24944                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24945                 }
24946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24947                 if (r->out.count == NULL) {
24948                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24949                 }
24950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24951                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24952         }
24953         return NDR_ERR_SUCCESS;
24954 }
24955
24956 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24957 {
24958         uint32_t _ptr_servername;
24959         uint32_t size_servername_1 = 0;
24960         uint32_t length_servername_1 = 0;
24961         uint32_t _ptr_buffer;
24962         uint32_t _ptr_info;
24963         TALLOC_CTX *_mem_save_servername_0;
24964         TALLOC_CTX *_mem_save_buffer_0;
24965         TALLOC_CTX *_mem_save_info_0;
24966         TALLOC_CTX *_mem_save_needed_0;
24967         TALLOC_CTX *_mem_save_count_0;
24968         if (flags & NDR_IN) {
24969                 ZERO_STRUCT(r->out);
24970
24971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24972                 if (_ptr_servername) {
24973                         NDR_PULL_ALLOC(ndr, r->in.servername);
24974                 } else {
24975                         r->in.servername = NULL;
24976                 }
24977                 if (r->in.servername) {
24978                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24979                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24982                         size_servername_1 = ndr_get_array_size(ndr, &r->in.servername);
24983                         length_servername_1 = ndr_get_array_length(ndr, &r->in.servername);
24984                         if (length_servername_1 > size_servername_1) {
24985                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
24986                         }
24987                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
24988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
24989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24990                 }
24991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24992                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24993                 if (_ptr_buffer) {
24994                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24995                 } else {
24996                         r->in.buffer = NULL;
24997                 }
24998                 if (r->in.buffer) {
24999                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25000                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25001                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25003                 }
25004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25005                 NDR_PULL_ALLOC(ndr, r->out.needed);
25006                 ZERO_STRUCTP(r->out.needed);
25007                 NDR_PULL_ALLOC(ndr, r->out.count);
25008                 ZERO_STRUCTP(r->out.count);
25009         }
25010         if (flags & NDR_OUT) {
25011                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25012                 if (_ptr_info) {
25013                         NDR_PULL_ALLOC(ndr, r->out.info);
25014                 } else {
25015                         r->out.info = NULL;
25016                 }
25017                 if (r->out.info) {
25018                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25019                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25020                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25021                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25022                 }
25023                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25024                         NDR_PULL_ALLOC(ndr, r->out.needed);
25025                 }
25026                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25027                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25030                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25031                         NDR_PULL_ALLOC(ndr, r->out.count);
25032                 }
25033                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25034                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25038         }
25039         return NDR_ERR_SUCCESS;
25040 }
25041
25042 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
25043 {
25044         uint32_t cntr_info_0;
25045         if (flags & NDR_IN) {
25046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25048         }
25049         if (flags & NDR_OUT) {
25050                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25051                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25052                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25053                 }
25054                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25055                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25056                 }
25057         }
25058         return NDR_ERR_SUCCESS;
25059 }
25060
25061 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
25062 {
25063         uint32_t size_info_0 = 0;
25064         uint32_t cntr_info_0;
25065         TALLOC_CTX *_mem_save_info_0;
25066         if (flags & NDR_IN) {
25067                 ZERO_STRUCT(r->out);
25068
25069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25071         }
25072         if (flags & NDR_OUT) {
25073                 size_info_0 = r->in.count;
25074                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
25075                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25076                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25077                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
25078                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25079                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25080                 }
25081                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
25082                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25083                 }
25084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25085         }
25086         return NDR_ERR_SUCCESS;
25087 }
25088
25089 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
25090 {
25091         uint32_t cntr_info_2;
25092         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
25093         ndr->depth++;
25094         if (flags & NDR_SET_VALUES) {
25095                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25096         }
25097         if (flags & NDR_IN) {
25098                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
25099                 ndr->depth++;
25100                 ndr_print_ptr(ndr, "servername", r->in.servername);
25101                 ndr->depth++;
25102                 if (r->in.servername) {
25103                         ndr_print_string(ndr, "servername", r->in.servername);
25104                 }
25105                 ndr->depth--;
25106                 ndr_print_uint32(ndr, "level", r->in.level);
25107                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25108                 ndr->depth++;
25109                 if (r->in.buffer) {
25110                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25111                 }
25112                 ndr->depth--;
25113                 ndr_print_uint32(ndr, "offered", r->in.offered);
25114                 ndr->depth--;
25115         }
25116         if (flags & NDR_OUT) {
25117                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
25118                 ndr->depth++;
25119                 ndr_print_ptr(ndr, "count", r->out.count);
25120                 ndr->depth++;
25121                 ndr_print_uint32(ndr, "count", *r->out.count);
25122                 ndr->depth--;
25123                 ndr_print_ptr(ndr, "info", r->out.info);
25124                 ndr->depth++;
25125                 ndr_print_ptr(ndr, "info", *r->out.info);
25126                 ndr->depth++;
25127                 if (*r->out.info) {
25128                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25129                         ndr->depth++;
25130                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25131                                 char *idx_2=NULL;
25132                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25133                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25134                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25135                                         free(idx_2);
25136                                 }
25137                         }
25138                         ndr->depth--;
25139                 }
25140                 ndr->depth--;
25141                 ndr->depth--;
25142                 ndr_print_ptr(ndr, "needed", r->out.needed);
25143                 ndr->depth++;
25144                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25145                 ndr->depth--;
25146                 ndr_print_WERROR(ndr, "result", r->out.result);
25147                 ndr->depth--;
25148         }
25149         ndr->depth--;
25150 }
25151
25152 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
25153 {
25154         if (flags & NDR_IN) {
25155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25156                 if (r->in.servername) {
25157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25158                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25159                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25160                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25161                 }
25162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25164                 if (r->in.buffer) {
25165                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25166                 }
25167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25168         }
25169         if (flags & NDR_OUT) {
25170                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25171                 if (r->out.info) {
25172                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25173                 }
25174                 if (r->out.needed == NULL) {
25175                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25176                 }
25177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25178                 if (r->out.count == NULL) {
25179                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25180                 }
25181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25182                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25183         }
25184         return NDR_ERR_SUCCESS;
25185 }
25186
25187 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
25188 {
25189         uint32_t _ptr_servername;
25190         uint32_t size_servername_1 = 0;
25191         uint32_t length_servername_1 = 0;
25192         uint32_t _ptr_buffer;
25193         uint32_t _ptr_info;
25194         TALLOC_CTX *_mem_save_servername_0;
25195         TALLOC_CTX *_mem_save_buffer_0;
25196         TALLOC_CTX *_mem_save_info_0;
25197         TALLOC_CTX *_mem_save_needed_0;
25198         TALLOC_CTX *_mem_save_count_0;
25199         if (flags & NDR_IN) {
25200                 ZERO_STRUCT(r->out);
25201
25202                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25203                 if (_ptr_servername) {
25204                         NDR_PULL_ALLOC(ndr, r->in.servername);
25205                 } else {
25206                         r->in.servername = NULL;
25207                 }
25208                 if (r->in.servername) {
25209                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25210                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25213                         size_servername_1 = ndr_get_array_size(ndr, &r->in.servername);
25214                         length_servername_1 = ndr_get_array_length(ndr, &r->in.servername);
25215                         if (length_servername_1 > size_servername_1) {
25216                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
25217                         }
25218                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
25219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
25220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25221                 }
25222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25224                 if (_ptr_buffer) {
25225                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25226                 } else {
25227                         r->in.buffer = NULL;
25228                 }
25229                 if (r->in.buffer) {
25230                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25231                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25232                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25234                 }
25235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25236                 NDR_PULL_ALLOC(ndr, r->out.needed);
25237                 ZERO_STRUCTP(r->out.needed);
25238                 NDR_PULL_ALLOC(ndr, r->out.count);
25239                 ZERO_STRUCTP(r->out.count);
25240         }
25241         if (flags & NDR_OUT) {
25242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25243                 if (_ptr_info) {
25244                         NDR_PULL_ALLOC(ndr, r->out.info);
25245                 } else {
25246                         r->out.info = NULL;
25247                 }
25248                 if (r->out.info) {
25249                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25250                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25251                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25253                 }
25254                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25255                         NDR_PULL_ALLOC(ndr, r->out.needed);
25256                 }
25257                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25258                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25260                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25262                         NDR_PULL_ALLOC(ndr, r->out.count);
25263                 }
25264                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25265                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25268                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25269         }
25270         return NDR_ERR_SUCCESS;
25271 }
25272
25273 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
25274 {
25275         uint32_t cntr_info_0;
25276         if (flags & NDR_IN) {
25277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25279         }
25280         if (flags & NDR_OUT) {
25281                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25282                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25283                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25284                 }
25285                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25286                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25287                 }
25288         }
25289         return NDR_ERR_SUCCESS;
25290 }
25291
25292 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
25293 {
25294         uint32_t size_info_0 = 0;
25295         uint32_t cntr_info_0;
25296         TALLOC_CTX *_mem_save_info_0;
25297         if (flags & NDR_IN) {
25298                 ZERO_STRUCT(r->out);
25299
25300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25302         }
25303         if (flags & NDR_OUT) {
25304                 size_info_0 = r->in.count;
25305                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
25306                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25307                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25308                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
25309                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25310                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25311                 }
25312                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
25313                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25314                 }
25315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25316         }
25317         return NDR_ERR_SUCCESS;
25318 }
25319
25320 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
25321 {
25322         uint32_t cntr_info_2;
25323         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
25324         ndr->depth++;
25325         if (flags & NDR_SET_VALUES) {
25326                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25327         }
25328         if (flags & NDR_IN) {
25329                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
25330                 ndr->depth++;
25331                 ndr_print_ptr(ndr, "servername", r->in.servername);
25332                 ndr->depth++;
25333                 if (r->in.servername) {
25334                         ndr_print_string(ndr, "servername", r->in.servername);
25335                 }
25336                 ndr->depth--;
25337                 ndr_print_uint32(ndr, "level", r->in.level);
25338                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25339                 ndr->depth++;
25340                 if (r->in.buffer) {
25341                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25342                 }
25343                 ndr->depth--;
25344                 ndr_print_uint32(ndr, "offered", r->in.offered);
25345                 ndr->depth--;
25346         }
25347         if (flags & NDR_OUT) {
25348                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
25349                 ndr->depth++;
25350                 ndr_print_ptr(ndr, "count", r->out.count);
25351                 ndr->depth++;
25352                 ndr_print_uint32(ndr, "count", *r->out.count);
25353                 ndr->depth--;
25354                 ndr_print_ptr(ndr, "info", r->out.info);
25355                 ndr->depth++;
25356                 ndr_print_ptr(ndr, "info", *r->out.info);
25357                 ndr->depth++;
25358                 if (*r->out.info) {
25359                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25360                         ndr->depth++;
25361                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25362                                 char *idx_2=NULL;
25363                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25364                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25365                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25366                                         free(idx_2);
25367                                 }
25368                         }
25369                         ndr->depth--;
25370                 }
25371                 ndr->depth--;
25372                 ndr->depth--;
25373                 ndr_print_ptr(ndr, "needed", r->out.needed);
25374                 ndr->depth++;
25375                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25376                 ndr->depth--;
25377                 ndr_print_WERROR(ndr, "result", r->out.result);
25378                 ndr->depth--;
25379         }
25380         ndr->depth--;
25381 }
25382
25383 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
25384 {
25385         if (flags & NDR_IN) {
25386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
25387                 if (r->in.server_name) {
25388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25389                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25390                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25391                         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));
25392                 }
25393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
25394                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25395                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25396                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25397                 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));
25398         }
25399         if (flags & NDR_OUT) {
25400                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25401         }
25402         return NDR_ERR_SUCCESS;
25403 }
25404
25405 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
25406 {
25407         uint32_t _ptr_server_name;
25408         uint32_t size_server_name_1 = 0;
25409         uint32_t length_server_name_1 = 0;
25410         uint32_t size_monitor_name_0 = 0;
25411         uint32_t length_monitor_name_0 = 0;
25412         TALLOC_CTX *_mem_save_server_name_0;
25413         if (flags & NDR_IN) {
25414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
25415                 if (_ptr_server_name) {
25416                         NDR_PULL_ALLOC(ndr, r->in.server_name);
25417                 } else {
25418                         r->in.server_name = NULL;
25419                 }
25420                 if (r->in.server_name) {
25421                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25422                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
25423                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25424                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25425                         size_server_name_1 = ndr_get_array_size(ndr, &r->in.server_name);
25426                         length_server_name_1 = ndr_get_array_length(ndr, &r->in.server_name);
25427                         if (length_server_name_1 > size_server_name_1) {
25428                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_name_1, length_server_name_1);
25429                         }
25430                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_name_1, sizeof(uint16_t)));
25431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, length_server_name_1, sizeof(uint16_t), CH_UTF16));
25432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
25433                 }
25434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
25435                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
25436                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
25437                 size_monitor_name_0 = ndr_get_array_size(ndr, &r->in.monitor_name);
25438                 length_monitor_name_0 = ndr_get_array_length(ndr, &r->in.monitor_name);
25439                 if (length_monitor_name_0 > size_monitor_name_0) {
25440                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_monitor_name_0, length_monitor_name_0);
25441                 }
25442                 NDR_CHECK(ndr_check_string_terminator(ndr, length_monitor_name_0, sizeof(uint16_t)));
25443                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.monitor_name, length_monitor_name_0, sizeof(uint16_t), CH_UTF16));
25444         }
25445         if (flags & NDR_OUT) {
25446                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25447         }
25448         return NDR_ERR_SUCCESS;
25449 }
25450
25451 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
25452 {
25453         ndr_print_struct(ndr, name, "spoolss_AddPort");
25454         ndr->depth++;
25455         if (flags & NDR_SET_VALUES) {
25456                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25457         }
25458         if (flags & NDR_IN) {
25459                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
25460                 ndr->depth++;
25461                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
25462                 ndr->depth++;
25463                 if (r->in.server_name) {
25464                         ndr_print_string(ndr, "server_name", r->in.server_name);
25465                 }
25466                 ndr->depth--;
25467                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
25468                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
25469                 ndr->depth--;
25470         }
25471         if (flags & NDR_OUT) {
25472                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
25473                 ndr->depth++;
25474                 ndr_print_WERROR(ndr, "result", r->out.result);
25475                 ndr->depth--;
25476         }
25477         ndr->depth--;
25478 }
25479
25480 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
25481 {
25482         if (flags & NDR_IN) {
25483         }
25484         if (flags & NDR_OUT) {
25485                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25486         }
25487         return NDR_ERR_SUCCESS;
25488 }
25489
25490 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
25491 {
25492         if (flags & NDR_IN) {
25493         }
25494         if (flags & NDR_OUT) {
25495                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25496         }
25497         return NDR_ERR_SUCCESS;
25498 }
25499
25500 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
25501 {
25502         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
25503         ndr->depth++;
25504         if (flags & NDR_SET_VALUES) {
25505                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25506         }
25507         if (flags & NDR_IN) {
25508                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
25509                 ndr->depth++;
25510                 ndr->depth--;
25511         }
25512         if (flags & NDR_OUT) {
25513                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
25514                 ndr->depth++;
25515                 ndr_print_WERROR(ndr, "result", r->out.result);
25516                 ndr->depth--;
25517         }
25518         ndr->depth--;
25519 }
25520
25521 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
25522 {
25523         if (flags & NDR_IN) {
25524         }
25525         if (flags & NDR_OUT) {
25526                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25527         }
25528         return NDR_ERR_SUCCESS;
25529 }
25530
25531 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
25532 {
25533         if (flags & NDR_IN) {
25534         }
25535         if (flags & NDR_OUT) {
25536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25537         }
25538         return NDR_ERR_SUCCESS;
25539 }
25540
25541 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
25542 {
25543         ndr_print_struct(ndr, name, "spoolss_DeletePort");
25544         ndr->depth++;
25545         if (flags & NDR_SET_VALUES) {
25546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25547         }
25548         if (flags & NDR_IN) {
25549                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
25550                 ndr->depth++;
25551                 ndr->depth--;
25552         }
25553         if (flags & NDR_OUT) {
25554                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
25555                 ndr->depth++;
25556                 ndr_print_WERROR(ndr, "result", r->out.result);
25557                 ndr->depth--;
25558         }
25559         ndr->depth--;
25560 }
25561
25562 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
25563 {
25564         if (flags & NDR_IN) {
25565                 if (r->in.handle == NULL) {
25566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25567                 }
25568                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25569                 if (r->in.devmode_ctr == NULL) {
25570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25571                 }
25572                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25573         }
25574         if (flags & NDR_OUT) {
25575                 if (r->out.gdi_handle == NULL) {
25576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25577                 }
25578                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25580         }
25581         return NDR_ERR_SUCCESS;
25582 }
25583
25584 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
25585 {
25586         TALLOC_CTX *_mem_save_handle_0;
25587         TALLOC_CTX *_mem_save_gdi_handle_0;
25588         TALLOC_CTX *_mem_save_devmode_ctr_0;
25589         if (flags & NDR_IN) {
25590                 ZERO_STRUCT(r->out);
25591
25592                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25593                         NDR_PULL_ALLOC(ndr, r->in.handle);
25594                 }
25595                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25596                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25597                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25599                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25600                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25601                 }
25602                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25603                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25604                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25606                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25607                 ZERO_STRUCTP(r->out.gdi_handle);
25608         }
25609         if (flags & NDR_OUT) {
25610                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25611                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25612                 }
25613                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25614                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25615                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25616                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25617                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25618         }
25619         return NDR_ERR_SUCCESS;
25620 }
25621
25622 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
25623 {
25624         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
25625         ndr->depth++;
25626         if (flags & NDR_SET_VALUES) {
25627                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25628         }
25629         if (flags & NDR_IN) {
25630                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25631                 ndr->depth++;
25632                 ndr_print_ptr(ndr, "handle", r->in.handle);
25633                 ndr->depth++;
25634                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25635                 ndr->depth--;
25636                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25637                 ndr->depth++;
25638                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25639                 ndr->depth--;
25640                 ndr->depth--;
25641         }
25642         if (flags & NDR_OUT) {
25643                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25644                 ndr->depth++;
25645                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25646                 ndr->depth++;
25647                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25648                 ndr->depth--;
25649                 ndr_print_WERROR(ndr, "result", r->out.result);
25650                 ndr->depth--;
25651         }
25652         ndr->depth--;
25653 }
25654
25655 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25656 {
25657         if (flags & NDR_IN) {
25658         }
25659         if (flags & NDR_OUT) {
25660                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25661         }
25662         return NDR_ERR_SUCCESS;
25663 }
25664
25665 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25666 {
25667         if (flags & NDR_IN) {
25668         }
25669         if (flags & NDR_OUT) {
25670                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25671         }
25672         return NDR_ERR_SUCCESS;
25673 }
25674
25675 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25676 {
25677         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25678         ndr->depth++;
25679         if (flags & NDR_SET_VALUES) {
25680                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25681         }
25682         if (flags & NDR_IN) {
25683                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25684                 ndr->depth++;
25685                 ndr->depth--;
25686         }
25687         if (flags & NDR_OUT) {
25688                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25689                 ndr->depth++;
25690                 ndr_print_WERROR(ndr, "result", r->out.result);
25691                 ndr->depth--;
25692         }
25693         ndr->depth--;
25694 }
25695
25696 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25697 {
25698         if (flags & NDR_IN) {
25699                 if (r->in.gdi_handle == NULL) {
25700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25701                 }
25702                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25703         }
25704         if (flags & NDR_OUT) {
25705                 if (r->out.gdi_handle == NULL) {
25706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25707                 }
25708                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25709                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25710         }
25711         return NDR_ERR_SUCCESS;
25712 }
25713
25714 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25715 {
25716         TALLOC_CTX *_mem_save_gdi_handle_0;
25717         if (flags & NDR_IN) {
25718                 ZERO_STRUCT(r->out);
25719
25720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25721                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25722                 }
25723                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25724                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25725                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25727                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25728                 *r->out.gdi_handle = *r->in.gdi_handle;
25729         }
25730         if (flags & NDR_OUT) {
25731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25732                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25733                 }
25734                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25735                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25738                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25739         }
25740         return NDR_ERR_SUCCESS;
25741 }
25742
25743 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25744 {
25745         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25746         ndr->depth++;
25747         if (flags & NDR_SET_VALUES) {
25748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25749         }
25750         if (flags & NDR_IN) {
25751                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25752                 ndr->depth++;
25753                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25754                 ndr->depth++;
25755                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25756                 ndr->depth--;
25757                 ndr->depth--;
25758         }
25759         if (flags & NDR_OUT) {
25760                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25761                 ndr->depth++;
25762                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25763                 ndr->depth++;
25764                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25765                 ndr->depth--;
25766                 ndr_print_WERROR(ndr, "result", r->out.result);
25767                 ndr->depth--;
25768         }
25769         ndr->depth--;
25770 }
25771
25772 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25773 {
25774         if (flags & NDR_IN) {
25775         }
25776         if (flags & NDR_OUT) {
25777                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25778         }
25779         return NDR_ERR_SUCCESS;
25780 }
25781
25782 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25783 {
25784         if (flags & NDR_IN) {
25785         }
25786         if (flags & NDR_OUT) {
25787                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25788         }
25789         return NDR_ERR_SUCCESS;
25790 }
25791
25792 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25793 {
25794         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25795         ndr->depth++;
25796         if (flags & NDR_SET_VALUES) {
25797                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25798         }
25799         if (flags & NDR_IN) {
25800                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25801                 ndr->depth++;
25802                 ndr->depth--;
25803         }
25804         if (flags & NDR_OUT) {
25805                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25806                 ndr->depth++;
25807                 ndr_print_WERROR(ndr, "result", r->out.result);
25808                 ndr->depth--;
25809         }
25810         ndr->depth--;
25811 }
25812
25813 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25814 {
25815         if (flags & NDR_IN) {
25816         }
25817         if (flags & NDR_OUT) {
25818                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25819         }
25820         return NDR_ERR_SUCCESS;
25821 }
25822
25823 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25824 {
25825         if (flags & NDR_IN) {
25826         }
25827         if (flags & NDR_OUT) {
25828                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25829         }
25830         return NDR_ERR_SUCCESS;
25831 }
25832
25833 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25834 {
25835         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25836         ndr->depth++;
25837         if (flags & NDR_SET_VALUES) {
25838                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25839         }
25840         if (flags & NDR_IN) {
25841                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25842                 ndr->depth++;
25843                 ndr->depth--;
25844         }
25845         if (flags & NDR_OUT) {
25846                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25847                 ndr->depth++;
25848                 ndr_print_WERROR(ndr, "result", r->out.result);
25849                 ndr->depth--;
25850         }
25851         ndr->depth--;
25852 }
25853
25854 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25855 {
25856         if (flags & NDR_IN) {
25857         }
25858         if (flags & NDR_OUT) {
25859                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25860         }
25861         return NDR_ERR_SUCCESS;
25862 }
25863
25864 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25865 {
25866         if (flags & NDR_IN) {
25867         }
25868         if (flags & NDR_OUT) {
25869                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25870         }
25871         return NDR_ERR_SUCCESS;
25872 }
25873
25874 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25875 {
25876         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25877         ndr->depth++;
25878         if (flags & NDR_SET_VALUES) {
25879                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25880         }
25881         if (flags & NDR_IN) {
25882                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25883                 ndr->depth++;
25884                 ndr->depth--;
25885         }
25886         if (flags & NDR_OUT) {
25887                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25888                 ndr->depth++;
25889                 ndr_print_WERROR(ndr, "result", r->out.result);
25890                 ndr->depth--;
25891         }
25892         ndr->depth--;
25893 }
25894
25895 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25896 {
25897         if (flags & NDR_IN) {
25898         }
25899         if (flags & NDR_OUT) {
25900                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25901         }
25902         return NDR_ERR_SUCCESS;
25903 }
25904
25905 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25906 {
25907         if (flags & NDR_IN) {
25908         }
25909         if (flags & NDR_OUT) {
25910                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25911         }
25912         return NDR_ERR_SUCCESS;
25913 }
25914
25915 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25916 {
25917         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25918         ndr->depth++;
25919         if (flags & NDR_SET_VALUES) {
25920                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25921         }
25922         if (flags & NDR_IN) {
25923                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25924                 ndr->depth++;
25925                 ndr->depth--;
25926         }
25927         if (flags & NDR_OUT) {
25928                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25929                 ndr->depth++;
25930                 ndr_print_WERROR(ndr, "result", r->out.result);
25931                 ndr->depth--;
25932         }
25933         ndr->depth--;
25934 }
25935
25936 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25937 {
25938         if (flags & NDR_IN) {
25939         }
25940         if (flags & NDR_OUT) {
25941                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25942         }
25943         return NDR_ERR_SUCCESS;
25944 }
25945
25946 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25947 {
25948         if (flags & NDR_IN) {
25949         }
25950         if (flags & NDR_OUT) {
25951                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25952         }
25953         return NDR_ERR_SUCCESS;
25954 }
25955
25956 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25957 {
25958         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25959         ndr->depth++;
25960         if (flags & NDR_SET_VALUES) {
25961                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25962         }
25963         if (flags & NDR_IN) {
25964                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25965                 ndr->depth++;
25966                 ndr->depth--;
25967         }
25968         if (flags & NDR_OUT) {
25969                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25970                 ndr->depth++;
25971                 ndr_print_WERROR(ndr, "result", r->out.result);
25972                 ndr->depth--;
25973         }
25974         ndr->depth--;
25975 }
25976
25977 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25978 {
25979         if (flags & NDR_IN) {
25980         }
25981         if (flags & NDR_OUT) {
25982                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25983         }
25984         return NDR_ERR_SUCCESS;
25985 }
25986
25987 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25988 {
25989         if (flags & NDR_IN) {
25990         }
25991         if (flags & NDR_OUT) {
25992                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25993         }
25994         return NDR_ERR_SUCCESS;
25995 }
25996
25997 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25998 {
25999         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
26000         ndr->depth++;
26001         if (flags & NDR_SET_VALUES) {
26002                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26003         }
26004         if (flags & NDR_IN) {
26005                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
26006                 ndr->depth++;
26007                 ndr->depth--;
26008         }
26009         if (flags & NDR_OUT) {
26010                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
26011                 ndr->depth++;
26012                 ndr_print_WERROR(ndr, "result", r->out.result);
26013                 ndr->depth--;
26014         }
26015         ndr->depth--;
26016 }
26017
26018 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
26019 {
26020         if (flags & NDR_IN) {
26021         }
26022         if (flags & NDR_OUT) {
26023                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26024         }
26025         return NDR_ERR_SUCCESS;
26026 }
26027
26028 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
26029 {
26030         if (flags & NDR_IN) {
26031         }
26032         if (flags & NDR_OUT) {
26033                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26034         }
26035         return NDR_ERR_SUCCESS;
26036 }
26037
26038 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
26039 {
26040         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
26041         ndr->depth++;
26042         if (flags & NDR_SET_VALUES) {
26043                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26044         }
26045         if (flags & NDR_IN) {
26046                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
26047                 ndr->depth++;
26048                 ndr->depth--;
26049         }
26050         if (flags & NDR_OUT) {
26051                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
26052                 ndr->depth++;
26053                 ndr_print_WERROR(ndr, "result", r->out.result);
26054                 ndr->depth--;
26055         }
26056         ndr->depth--;
26057 }
26058
26059 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
26060 {
26061         if (flags & NDR_IN) {
26062         }
26063         if (flags & NDR_OUT) {
26064                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26065         }
26066         return NDR_ERR_SUCCESS;
26067 }
26068
26069 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
26070 {
26071         if (flags & NDR_IN) {
26072         }
26073         if (flags & NDR_OUT) {
26074                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26075         }
26076         return NDR_ERR_SUCCESS;
26077 }
26078
26079 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
26080 {
26081         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
26082         ndr->depth++;
26083         if (flags & NDR_SET_VALUES) {
26084                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26085         }
26086         if (flags & NDR_IN) {
26087                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
26088                 ndr->depth++;
26089                 ndr->depth--;
26090         }
26091         if (flags & NDR_OUT) {
26092                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
26093                 ndr->depth++;
26094                 ndr_print_WERROR(ndr, "result", r->out.result);
26095                 ndr->depth--;
26096         }
26097         ndr->depth--;
26098 }
26099
26100 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
26101 {
26102         if (flags & NDR_IN) {
26103                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26104                 if (r->in.servername) {
26105                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26106                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26107                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26109                 }
26110                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
26111                 if (r->in.print_processor_name) {
26112                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
26113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
26115                         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));
26116                 }
26117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26119                 if (r->in.buffer) {
26120                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26121                 }
26122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26123         }
26124         if (flags & NDR_OUT) {
26125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26126                 if (r->out.info) {
26127                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
26128                 }
26129                 if (r->out.needed == NULL) {
26130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26131                 }
26132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26133                 if (r->out.count == NULL) {
26134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26135                 }
26136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26138         }
26139         return NDR_ERR_SUCCESS;
26140 }
26141
26142 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
26143 {
26144         uint32_t _ptr_servername;
26145         uint32_t size_servername_1 = 0;
26146         uint32_t length_servername_1 = 0;
26147         uint32_t _ptr_print_processor_name;
26148         uint32_t size_print_processor_name_1 = 0;
26149         uint32_t length_print_processor_name_1 = 0;
26150         uint32_t _ptr_buffer;
26151         uint32_t _ptr_info;
26152         TALLOC_CTX *_mem_save_servername_0;
26153         TALLOC_CTX *_mem_save_print_processor_name_0;
26154         TALLOC_CTX *_mem_save_buffer_0;
26155         TALLOC_CTX *_mem_save_info_0;
26156         TALLOC_CTX *_mem_save_needed_0;
26157         TALLOC_CTX *_mem_save_count_0;
26158         if (flags & NDR_IN) {
26159                 ZERO_STRUCT(r->out);
26160
26161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26162                 if (_ptr_servername) {
26163                         NDR_PULL_ALLOC(ndr, r->in.servername);
26164                 } else {
26165                         r->in.servername = NULL;
26166                 }
26167                 if (r->in.servername) {
26168                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26169                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26170                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26171                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26172                         size_servername_1 = ndr_get_array_size(ndr, &r->in.servername);
26173                         length_servername_1 = ndr_get_array_length(ndr, &r->in.servername);
26174                         if (length_servername_1 > size_servername_1) {
26175                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
26176                         }
26177                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
26178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
26179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26180                 }
26181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
26182                 if (_ptr_print_processor_name) {
26183                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
26184                 } else {
26185                         r->in.print_processor_name = NULL;
26186                 }
26187                 if (r->in.print_processor_name) {
26188                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
26189                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
26190                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
26191                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
26192                         size_print_processor_name_1 = ndr_get_array_size(ndr, &r->in.print_processor_name);
26193                         length_print_processor_name_1 = ndr_get_array_length(ndr, &r->in.print_processor_name);
26194                         if (length_print_processor_name_1 > size_print_processor_name_1) {
26195                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_print_processor_name_1, length_print_processor_name_1);
26196                         }
26197                         NDR_CHECK(ndr_check_string_terminator(ndr, length_print_processor_name_1, sizeof(uint16_t)));
26198                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.print_processor_name, length_print_processor_name_1, sizeof(uint16_t), CH_UTF16));
26199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
26200                 }
26201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26202                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26203                 if (_ptr_buffer) {
26204                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26205                 } else {
26206                         r->in.buffer = NULL;
26207                 }
26208                 if (r->in.buffer) {
26209                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26210                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26211                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26213                 }
26214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26215                 NDR_PULL_ALLOC(ndr, r->out.needed);
26216                 ZERO_STRUCTP(r->out.needed);
26217                 NDR_PULL_ALLOC(ndr, r->out.count);
26218                 ZERO_STRUCTP(r->out.count);
26219         }
26220         if (flags & NDR_OUT) {
26221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26222                 if (_ptr_info) {
26223                         NDR_PULL_ALLOC(ndr, r->out.info);
26224                 } else {
26225                         r->out.info = NULL;
26226                 }
26227                 if (r->out.info) {
26228                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26229                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26230                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26232                 }
26233                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26234                         NDR_PULL_ALLOC(ndr, r->out.needed);
26235                 }
26236                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26237                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26239                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26240                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26241                         NDR_PULL_ALLOC(ndr, r->out.count);
26242                 }
26243                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26244                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26246                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26247                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26248         }
26249         return NDR_ERR_SUCCESS;
26250 }
26251
26252 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
26253 {
26254         uint32_t cntr_info_0;
26255         if (flags & NDR_IN) {
26256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26258         }
26259         if (flags & NDR_OUT) {
26260                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26261                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26262                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26263                 }
26264                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26265                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26266                 }
26267         }
26268         return NDR_ERR_SUCCESS;
26269 }
26270
26271 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
26272 {
26273         uint32_t size_info_0 = 0;
26274         uint32_t cntr_info_0;
26275         TALLOC_CTX *_mem_save_info_0;
26276         if (flags & NDR_IN) {
26277                 ZERO_STRUCT(r->out);
26278
26279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26281         }
26282         if (flags & NDR_OUT) {
26283                 size_info_0 = r->in.count;
26284                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
26285                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26286                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26287                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
26288                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26289                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26290                 }
26291                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
26292                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26293                 }
26294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26295         }
26296         return NDR_ERR_SUCCESS;
26297 }
26298
26299 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
26300 {
26301         uint32_t cntr_info_2;
26302         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
26303         ndr->depth++;
26304         if (flags & NDR_SET_VALUES) {
26305                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26306         }
26307         if (flags & NDR_IN) {
26308                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
26309                 ndr->depth++;
26310                 ndr_print_ptr(ndr, "servername", r->in.servername);
26311                 ndr->depth++;
26312                 if (r->in.servername) {
26313                         ndr_print_string(ndr, "servername", r->in.servername);
26314                 }
26315                 ndr->depth--;
26316                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
26317                 ndr->depth++;
26318                 if (r->in.print_processor_name) {
26319                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
26320                 }
26321                 ndr->depth--;
26322                 ndr_print_uint32(ndr, "level", r->in.level);
26323                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26324                 ndr->depth++;
26325                 if (r->in.buffer) {
26326                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26327                 }
26328                 ndr->depth--;
26329                 ndr_print_uint32(ndr, "offered", r->in.offered);
26330                 ndr->depth--;
26331         }
26332         if (flags & NDR_OUT) {
26333                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
26334                 ndr->depth++;
26335                 ndr_print_ptr(ndr, "count", r->out.count);
26336                 ndr->depth++;
26337                 ndr_print_uint32(ndr, "count", *r->out.count);
26338                 ndr->depth--;
26339                 ndr_print_ptr(ndr, "info", r->out.info);
26340                 ndr->depth++;
26341                 ndr_print_ptr(ndr, "info", *r->out.info);
26342                 ndr->depth++;
26343                 if (*r->out.info) {
26344                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26345                         ndr->depth++;
26346                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26347                                 char *idx_2=NULL;
26348                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26349                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
26350                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
26351                                         free(idx_2);
26352                                 }
26353                         }
26354                         ndr->depth--;
26355                 }
26356                 ndr->depth--;
26357                 ndr->depth--;
26358                 ndr_print_ptr(ndr, "needed", r->out.needed);
26359                 ndr->depth++;
26360                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26361                 ndr->depth--;
26362                 ndr_print_WERROR(ndr, "result", r->out.result);
26363                 ndr->depth--;
26364         }
26365         ndr->depth--;
26366 }
26367
26368 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
26369 {
26370         if (flags & NDR_IN) {
26371                 if (r->in.handle == NULL) {
26372                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26373                 }
26374                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
26376                 if (r->in.data_type) {
26377                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26380                         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));
26381                 }
26382                 if (r->in.devmode_ctr == NULL) {
26383                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26384                 }
26385                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26386         }
26387         if (flags & NDR_OUT) {
26388                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26389         }
26390         return NDR_ERR_SUCCESS;
26391 }
26392
26393 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
26394 {
26395         uint32_t _ptr_data_type;
26396         uint32_t size_data_type_1 = 0;
26397         uint32_t length_data_type_1 = 0;
26398         TALLOC_CTX *_mem_save_handle_0;
26399         TALLOC_CTX *_mem_save_data_type_0;
26400         TALLOC_CTX *_mem_save_devmode_ctr_0;
26401         if (flags & NDR_IN) {
26402                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26403                         NDR_PULL_ALLOC(ndr, r->in.handle);
26404                 }
26405                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26406                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26407                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26408                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
26410                 if (_ptr_data_type) {
26411                         NDR_PULL_ALLOC(ndr, r->in.data_type);
26412                 } else {
26413                         r->in.data_type = NULL;
26414                 }
26415                 if (r->in.data_type) {
26416                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26417                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
26418                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
26419                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
26420                         size_data_type_1 = ndr_get_array_size(ndr, &r->in.data_type);
26421                         length_data_type_1 = ndr_get_array_length(ndr, &r->in.data_type);
26422                         if (length_data_type_1 > size_data_type_1) {
26423                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_data_type_1, length_data_type_1);
26424                         }
26425                         NDR_CHECK(ndr_check_string_terminator(ndr, length_data_type_1, sizeof(uint16_t)));
26426                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.data_type, length_data_type_1, sizeof(uint16_t), CH_UTF16));
26427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
26428                 }
26429                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26430                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26431                 }
26432                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26433                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26434                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26435                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26436         }
26437         if (flags & NDR_OUT) {
26438                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26439         }
26440         return NDR_ERR_SUCCESS;
26441 }
26442
26443 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
26444 {
26445         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
26446         ndr->depth++;
26447         if (flags & NDR_SET_VALUES) {
26448                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26449         }
26450         if (flags & NDR_IN) {
26451                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
26452                 ndr->depth++;
26453                 ndr_print_ptr(ndr, "handle", r->in.handle);
26454                 ndr->depth++;
26455                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26456                 ndr->depth--;
26457                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
26458                 ndr->depth++;
26459                 if (r->in.data_type) {
26460                         ndr_print_string(ndr, "data_type", r->in.data_type);
26461                 }
26462                 ndr->depth--;
26463                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26464                 ndr->depth++;
26465                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26466                 ndr->depth--;
26467                 ndr->depth--;
26468         }
26469         if (flags & NDR_OUT) {
26470                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
26471                 ndr->depth++;
26472                 ndr_print_WERROR(ndr, "result", r->out.result);
26473                 ndr->depth--;
26474         }
26475         ndr->depth--;
26476 }
26477
26478 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
26479 {
26480         if (flags & NDR_IN) {
26481                 if (r->in.handle == NULL) {
26482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26483                 }
26484                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
26486                 if (r->in.architecture) {
26487                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26488                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26489                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26490                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26491                 }
26492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26494                 if (r->in.buffer) {
26495                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26496                 }
26497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
26499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
26500         }
26501         if (flags & NDR_OUT) {
26502                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26503                 if (r->out.info) {
26504                         {
26505                                 struct ndr_push *_ndr_info;
26506                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26507                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
26508                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26509                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26510                         }
26511                 }
26512                 if (r->out.needed == NULL) {
26513                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26514                 }
26515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26516                 if (r->out.server_major_version == NULL) {
26517                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26518                 }
26519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
26520                 if (r->out.server_minor_version == NULL) {
26521                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26522                 }
26523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
26524                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26525         }
26526         return NDR_ERR_SUCCESS;
26527 }
26528
26529 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
26530 {
26531         uint32_t _ptr_architecture;
26532         uint32_t size_architecture_1 = 0;
26533         uint32_t length_architecture_1 = 0;
26534         uint32_t _ptr_buffer;
26535         uint32_t _ptr_info;
26536         TALLOC_CTX *_mem_save_handle_0;
26537         TALLOC_CTX *_mem_save_architecture_0;
26538         TALLOC_CTX *_mem_save_buffer_0;
26539         TALLOC_CTX *_mem_save_info_0;
26540         TALLOC_CTX *_mem_save_needed_0;
26541         TALLOC_CTX *_mem_save_server_major_version_0;
26542         TALLOC_CTX *_mem_save_server_minor_version_0;
26543         if (flags & NDR_IN) {
26544                 ZERO_STRUCT(r->out);
26545
26546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26547                         NDR_PULL_ALLOC(ndr, r->in.handle);
26548                 }
26549                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26550                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26551                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26553                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
26554                 if (_ptr_architecture) {
26555                         NDR_PULL_ALLOC(ndr, r->in.architecture);
26556                 } else {
26557                         r->in.architecture = NULL;
26558                 }
26559                 if (r->in.architecture) {
26560                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
26561                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
26562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26564                         size_architecture_1 = ndr_get_array_size(ndr, &r->in.architecture);
26565                         length_architecture_1 = ndr_get_array_length(ndr, &r->in.architecture);
26566                         if (length_architecture_1 > size_architecture_1) {
26567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
26568                         }
26569                         NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
26570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
26571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
26572                 }
26573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26574                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26575                 if (_ptr_buffer) {
26576                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26577                 } else {
26578                         r->in.buffer = NULL;
26579                 }
26580                 if (r->in.buffer) {
26581                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26582                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26583                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26585                 }
26586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
26588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
26589                 NDR_PULL_ALLOC(ndr, r->out.needed);
26590                 ZERO_STRUCTP(r->out.needed);
26591                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26592                 ZERO_STRUCTP(r->out.server_major_version);
26593                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26594                 ZERO_STRUCTP(r->out.server_minor_version);
26595         }
26596         if (flags & NDR_OUT) {
26597                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26598                 if (_ptr_info) {
26599                         NDR_PULL_ALLOC(ndr, r->out.info);
26600                 } else {
26601                         r->out.info = NULL;
26602                 }
26603                 if (r->out.info) {
26604                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26605                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26606                         {
26607                                 struct ndr_pull *_ndr_info;
26608                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26609                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
26610                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26611                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26612                         }
26613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26614                 }
26615                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26616                         NDR_PULL_ALLOC(ndr, r->out.needed);
26617                 }
26618                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26619                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26623                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26624                 }
26625                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26626                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
26627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
26628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
26629                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26630                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26631                 }
26632                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26633                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
26634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
26635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
26636                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26637         }
26638         return NDR_ERR_SUCCESS;
26639 }
26640
26641 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
26642 {
26643         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
26644         ndr->depth++;
26645         if (flags & NDR_SET_VALUES) {
26646                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26647         }
26648         if (flags & NDR_IN) {
26649                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26650                 ndr->depth++;
26651                 ndr_print_ptr(ndr, "handle", r->in.handle);
26652                 ndr->depth++;
26653                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26654                 ndr->depth--;
26655                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
26656                 ndr->depth++;
26657                 if (r->in.architecture) {
26658                         ndr_print_string(ndr, "architecture", r->in.architecture);
26659                 }
26660                 ndr->depth--;
26661                 ndr_print_uint32(ndr, "level", r->in.level);
26662                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26663                 ndr->depth++;
26664                 if (r->in.buffer) {
26665                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26666                 }
26667                 ndr->depth--;
26668                 ndr_print_uint32(ndr, "offered", r->in.offered);
26669                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26670                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26671                 ndr->depth--;
26672         }
26673         if (flags & NDR_OUT) {
26674                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26675                 ndr->depth++;
26676                 ndr_print_ptr(ndr, "info", r->out.info);
26677                 ndr->depth++;
26678                 if (r->out.info) {
26679                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26680                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26681                 }
26682                 ndr->depth--;
26683                 ndr_print_ptr(ndr, "needed", r->out.needed);
26684                 ndr->depth++;
26685                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26686                 ndr->depth--;
26687                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26688                 ndr->depth++;
26689                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26690                 ndr->depth--;
26691                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26692                 ndr->depth++;
26693                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26694                 ndr->depth--;
26695                 ndr_print_WERROR(ndr, "result", r->out.result);
26696                 ndr->depth--;
26697         }
26698         ndr->depth--;
26699 }
26700
26701 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26702 {
26703         if (flags & NDR_IN) {
26704         }
26705         if (flags & NDR_OUT) {
26706                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26707         }
26708         return NDR_ERR_SUCCESS;
26709 }
26710
26711 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26712 {
26713         if (flags & NDR_IN) {
26714         }
26715         if (flags & NDR_OUT) {
26716                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26717         }
26718         return NDR_ERR_SUCCESS;
26719 }
26720
26721 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26722 {
26723         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26724         ndr->depth++;
26725         if (flags & NDR_SET_VALUES) {
26726                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26727         }
26728         if (flags & NDR_IN) {
26729                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26730                 ndr->depth++;
26731                 ndr->depth--;
26732         }
26733         if (flags & NDR_OUT) {
26734                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26735                 ndr->depth++;
26736                 ndr_print_WERROR(ndr, "result", r->out.result);
26737                 ndr->depth--;
26738         }
26739         ndr->depth--;
26740 }
26741
26742 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26743 {
26744         if (flags & NDR_IN) {
26745         }
26746         if (flags & NDR_OUT) {
26747                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26748         }
26749         return NDR_ERR_SUCCESS;
26750 }
26751
26752 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26753 {
26754         if (flags & NDR_IN) {
26755         }
26756         if (flags & NDR_OUT) {
26757                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26758         }
26759         return NDR_ERR_SUCCESS;
26760 }
26761
26762 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26763 {
26764         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26765         ndr->depth++;
26766         if (flags & NDR_SET_VALUES) {
26767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26768         }
26769         if (flags & NDR_IN) {
26770                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26771                 ndr->depth++;
26772                 ndr->depth--;
26773         }
26774         if (flags & NDR_OUT) {
26775                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26776                 ndr->depth++;
26777                 ndr_print_WERROR(ndr, "result", r->out.result);
26778                 ndr->depth--;
26779         }
26780         ndr->depth--;
26781 }
26782
26783 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26784 {
26785         if (flags & NDR_IN) {
26786                 if (r->in.handle == NULL) {
26787                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26788                 }
26789                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26790         }
26791         if (flags & NDR_OUT) {
26792                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26793         }
26794         return NDR_ERR_SUCCESS;
26795 }
26796
26797 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26798 {
26799         TALLOC_CTX *_mem_save_handle_0;
26800         if (flags & NDR_IN) {
26801                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26802                         NDR_PULL_ALLOC(ndr, r->in.handle);
26803                 }
26804                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26805                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26806                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26807                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26808         }
26809         if (flags & NDR_OUT) {
26810                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26811         }
26812         return NDR_ERR_SUCCESS;
26813 }
26814
26815 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26816 {
26817         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26818         ndr->depth++;
26819         if (flags & NDR_SET_VALUES) {
26820                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26821         }
26822         if (flags & NDR_IN) {
26823                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26824                 ndr->depth++;
26825                 ndr_print_ptr(ndr, "handle", r->in.handle);
26826                 ndr->depth++;
26827                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26828                 ndr->depth--;
26829                 ndr->depth--;
26830         }
26831         if (flags & NDR_OUT) {
26832                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26833                 ndr->depth++;
26834                 ndr_print_WERROR(ndr, "result", r->out.result);
26835                 ndr->depth--;
26836         }
26837         ndr->depth--;
26838 }
26839
26840 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26841 {
26842         if (flags & NDR_IN) {
26843         }
26844         if (flags & NDR_OUT) {
26845                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26846         }
26847         return NDR_ERR_SUCCESS;
26848 }
26849
26850 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26851 {
26852         if (flags & NDR_IN) {
26853         }
26854         if (flags & NDR_OUT) {
26855                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26856         }
26857         return NDR_ERR_SUCCESS;
26858 }
26859
26860 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26861 {
26862         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26863         ndr->depth++;
26864         if (flags & NDR_SET_VALUES) {
26865                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26866         }
26867         if (flags & NDR_IN) {
26868                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26869                 ndr->depth++;
26870                 ndr->depth--;
26871         }
26872         if (flags & NDR_OUT) {
26873                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26874                 ndr->depth++;
26875                 ndr_print_WERROR(ndr, "result", r->out.result);
26876                 ndr->depth--;
26877         }
26878         ndr->depth--;
26879 }
26880
26881 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26882 {
26883         if (flags & NDR_IN) {
26884                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26885                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26886                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26887                 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));
26888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26889                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26892                 if (r->in.buffer) {
26893                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26894                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26895                 }
26896         }
26897         if (flags & NDR_OUT) {
26898                 if (r->out.handle == NULL) {
26899                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26900                 }
26901                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26902                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26903         }
26904         return NDR_ERR_SUCCESS;
26905 }
26906
26907 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26908 {
26909         uint32_t size_server_name_0 = 0;
26910         uint32_t length_server_name_0 = 0;
26911         uint32_t _ptr_buffer;
26912         uint32_t size_buffer_1 = 0;
26913         TALLOC_CTX *_mem_save_buffer_0;
26914         TALLOC_CTX *_mem_save_handle_0;
26915         if (flags & NDR_IN) {
26916                 ZERO_STRUCT(r->out);
26917
26918                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26919                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26920                 size_server_name_0 = ndr_get_array_size(ndr, &r->in.server_name);
26921                 length_server_name_0 = ndr_get_array_length(ndr, &r->in.server_name);
26922                 if (length_server_name_0 > size_server_name_0) {
26923                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_name_0, length_server_name_0);
26924                 }
26925                 NDR_CHECK(ndr_check_string_terminator(ndr, length_server_name_0, sizeof(uint16_t)));
26926                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, length_server_name_0, sizeof(uint16_t), CH_UTF16));
26927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26928                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26930                 if (r->in.bufsize > 512) {
26931                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26932                 }
26933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26934                 if (_ptr_buffer) {
26935                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26936                 } else {
26937                         r->in.buffer = NULL;
26938                 }
26939                 if (r->in.buffer) {
26940                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26941                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26942                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26943                         size_buffer_1 = ndr_get_array_size(ndr, &r->in.buffer);
26944                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, size_buffer_1);
26945                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, size_buffer_1));
26946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26947                 }
26948                 NDR_PULL_ALLOC(ndr, r->out.handle);
26949                 ZERO_STRUCTP(r->out.handle);
26950                 if (r->in.buffer) {
26951                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26952                 }
26953         }
26954         if (flags & NDR_OUT) {
26955                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26956                         NDR_PULL_ALLOC(ndr, r->out.handle);
26957                 }
26958                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26959                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26960                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26961                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26962                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26963         }
26964         return NDR_ERR_SUCCESS;
26965 }
26966
26967 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26968 {
26969         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26970         ndr->depth++;
26971         if (flags & NDR_SET_VALUES) {
26972                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26973         }
26974         if (flags & NDR_IN) {
26975                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26976                 ndr->depth++;
26977                 ndr_print_string(ndr, "server_name", r->in.server_name);
26978                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26979                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26980                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26981                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26982                 ndr->depth++;
26983                 if (r->in.buffer) {
26984                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26985                 }
26986                 ndr->depth--;
26987                 ndr->depth--;
26988         }
26989         if (flags & NDR_OUT) {
26990                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26991                 ndr->depth++;
26992                 ndr_print_ptr(ndr, "handle", r->out.handle);
26993                 ndr->depth++;
26994                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26995                 ndr->depth--;
26996                 ndr_print_WERROR(ndr, "result", r->out.result);
26997                 ndr->depth--;
26998         }
26999         ndr->depth--;
27000 }
27001
27002 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
27003 {
27004         if (flags & NDR_IN) {
27005                 if (r->in.handle == NULL) {
27006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27007                 }
27008                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27009                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
27011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
27012                 if (r->in.buffer) {
27013                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
27014                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
27015                 }
27016         }
27017         if (flags & NDR_OUT) {
27018                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27019         }
27020         return NDR_ERR_SUCCESS;
27021 }
27022
27023 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
27024 {
27025         uint32_t _ptr_buffer;
27026         uint32_t size_buffer_1 = 0;
27027         TALLOC_CTX *_mem_save_handle_0;
27028         TALLOC_CTX *_mem_save_buffer_0;
27029         if (flags & NDR_IN) {
27030                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27031                         NDR_PULL_ALLOC(ndr, r->in.handle);
27032                 }
27033                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27034                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27035                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27037                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
27039                 if (r->in.bufsize > 512) {
27040                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
27041                 }
27042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
27043                 if (_ptr_buffer) {
27044                         NDR_PULL_ALLOC(ndr, r->in.buffer);
27045                 } else {
27046                         r->in.buffer = NULL;
27047                 }
27048                 if (r->in.buffer) {
27049                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27050                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
27051                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27052                         size_buffer_1 = ndr_get_array_size(ndr, &r->in.buffer);
27053                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, size_buffer_1);
27054                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, size_buffer_1));
27055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
27056                 }
27057                 if (r->in.buffer) {
27058                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
27059                 }
27060         }
27061         if (flags & NDR_OUT) {
27062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27063         }
27064         return NDR_ERR_SUCCESS;
27065 }
27066
27067 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
27068 {
27069         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
27070         ndr->depth++;
27071         if (flags & NDR_SET_VALUES) {
27072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27073         }
27074         if (flags & NDR_IN) {
27075                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
27076                 ndr->depth++;
27077                 ndr_print_ptr(ndr, "handle", r->in.handle);
27078                 ndr->depth++;
27079                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27080                 ndr->depth--;
27081                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27082                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
27083                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27084                 ndr->depth++;
27085                 if (r->in.buffer) {
27086                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
27087                 }
27088                 ndr->depth--;
27089                 ndr->depth--;
27090         }
27091         if (flags & NDR_OUT) {
27092                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
27093                 ndr->depth++;
27094                 ndr_print_WERROR(ndr, "result", r->out.result);
27095                 ndr->depth--;
27096         }
27097         ndr->depth--;
27098 }
27099
27100 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
27101 {
27102         if (flags & NDR_IN) {
27103                 if (r->in.handle == NULL) {
27104                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27105                 }
27106                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27107         }
27108         if (flags & NDR_OUT) {
27109                 if (r->out.handle == NULL) {
27110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27111                 }
27112                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27114         }
27115         return NDR_ERR_SUCCESS;
27116 }
27117
27118 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
27119 {
27120         TALLOC_CTX *_mem_save_handle_0;
27121         if (flags & NDR_IN) {
27122                 ZERO_STRUCT(r->out);
27123
27124                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27125                         NDR_PULL_ALLOC(ndr, r->in.handle);
27126                 }
27127                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27128                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27129                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27130                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27131                 NDR_PULL_ALLOC(ndr, r->out.handle);
27132                 *r->out.handle = *r->in.handle;
27133         }
27134         if (flags & NDR_OUT) {
27135                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27136                         NDR_PULL_ALLOC(ndr, r->out.handle);
27137                 }
27138                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27139                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27140                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27141                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27142                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27143         }
27144         return NDR_ERR_SUCCESS;
27145 }
27146
27147 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
27148 {
27149         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
27150         ndr->depth++;
27151         if (flags & NDR_SET_VALUES) {
27152                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27153         }
27154         if (flags & NDR_IN) {
27155                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
27156                 ndr->depth++;
27157                 ndr_print_ptr(ndr, "handle", r->in.handle);
27158                 ndr->depth++;
27159                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27160                 ndr->depth--;
27161                 ndr->depth--;
27162         }
27163         if (flags & NDR_OUT) {
27164                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
27165                 ndr->depth++;
27166                 ndr_print_ptr(ndr, "handle", r->out.handle);
27167                 ndr->depth++;
27168                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27169                 ndr->depth--;
27170                 ndr_print_WERROR(ndr, "result", r->out.result);
27171                 ndr->depth--;
27172         }
27173         ndr->depth--;
27174 }
27175
27176 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
27177 {
27178         if (flags & NDR_IN) {
27179         }
27180         if (flags & NDR_OUT) {
27181                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27182         }
27183         return NDR_ERR_SUCCESS;
27184 }
27185
27186 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
27187 {
27188         if (flags & NDR_IN) {
27189         }
27190         if (flags & NDR_OUT) {
27191                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27192         }
27193         return NDR_ERR_SUCCESS;
27194 }
27195
27196 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
27197 {
27198         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
27199         ndr->depth++;
27200         if (flags & NDR_SET_VALUES) {
27201                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27202         }
27203         if (flags & NDR_IN) {
27204                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
27205                 ndr->depth++;
27206                 ndr->depth--;
27207         }
27208         if (flags & NDR_OUT) {
27209                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
27210                 ndr->depth++;
27211                 ndr_print_WERROR(ndr, "result", r->out.result);
27212                 ndr->depth--;
27213         }
27214         ndr->depth--;
27215 }
27216
27217 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27218 {
27219         if (flags & NDR_IN) {
27220         }
27221         if (flags & NDR_OUT) {
27222                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27223         }
27224         return NDR_ERR_SUCCESS;
27225 }
27226
27227 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27228 {
27229         if (flags & NDR_IN) {
27230         }
27231         if (flags & NDR_OUT) {
27232                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27233         }
27234         return NDR_ERR_SUCCESS;
27235 }
27236
27237 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27238 {
27239         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
27240         ndr->depth++;
27241         if (flags & NDR_SET_VALUES) {
27242                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27243         }
27244         if (flags & NDR_IN) {
27245                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
27246                 ndr->depth++;
27247                 ndr->depth--;
27248         }
27249         if (flags & NDR_OUT) {
27250                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
27251                 ndr->depth++;
27252                 ndr_print_WERROR(ndr, "result", r->out.result);
27253                 ndr->depth--;
27254         }
27255         ndr->depth--;
27256 }
27257
27258 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
27259 {
27260         if (flags & NDR_IN) {
27261         }
27262         if (flags & NDR_OUT) {
27263                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27264         }
27265         return NDR_ERR_SUCCESS;
27266 }
27267
27268 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
27269 {
27270         if (flags & NDR_IN) {
27271         }
27272         if (flags & NDR_OUT) {
27273                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27274         }
27275         return NDR_ERR_SUCCESS;
27276 }
27277
27278 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
27279 {
27280         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
27281         ndr->depth++;
27282         if (flags & NDR_SET_VALUES) {
27283                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27284         }
27285         if (flags & NDR_IN) {
27286                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
27287                 ndr->depth++;
27288                 ndr->depth--;
27289         }
27290         if (flags & NDR_OUT) {
27291                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
27292                 ndr->depth++;
27293                 ndr_print_WERROR(ndr, "result", r->out.result);
27294                 ndr->depth--;
27295         }
27296         ndr->depth--;
27297 }
27298
27299 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
27300 {
27301         if (flags & NDR_IN) {
27302         }
27303         if (flags & NDR_OUT) {
27304                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27305         }
27306         return NDR_ERR_SUCCESS;
27307 }
27308
27309 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
27310 {
27311         if (flags & NDR_IN) {
27312         }
27313         if (flags & NDR_OUT) {
27314                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27315         }
27316         return NDR_ERR_SUCCESS;
27317 }
27318
27319 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
27320 {
27321         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
27322         ndr->depth++;
27323         if (flags & NDR_SET_VALUES) {
27324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27325         }
27326         if (flags & NDR_IN) {
27327                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
27328                 ndr->depth++;
27329                 ndr->depth--;
27330         }
27331         if (flags & NDR_OUT) {
27332                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
27333                 ndr->depth++;
27334                 ndr_print_WERROR(ndr, "result", r->out.result);
27335                 ndr->depth--;
27336         }
27337         ndr->depth--;
27338 }
27339
27340 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27341 {
27342         if (flags & NDR_IN) {
27343                 if (r->in.handle == NULL) {
27344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27345                 }
27346                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27347                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
27349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
27350                 if (r->in.local_machine) {
27351                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27352                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27353                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27354                         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));
27355                 }
27356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
27357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
27358                 if (r->in.notify_options) {
27359                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27360                 }
27361         }
27362         if (flags & NDR_OUT) {
27363                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27364         }
27365         return NDR_ERR_SUCCESS;
27366 }
27367
27368 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27369 {
27370         uint32_t _ptr_local_machine;
27371         uint32_t size_local_machine_1 = 0;
27372         uint32_t length_local_machine_1 = 0;
27373         uint32_t _ptr_notify_options;
27374         TALLOC_CTX *_mem_save_handle_0;
27375         TALLOC_CTX *_mem_save_local_machine_0;
27376         TALLOC_CTX *_mem_save_notify_options_0;
27377         if (flags & NDR_IN) {
27378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27379                         NDR_PULL_ALLOC(ndr, r->in.handle);
27380                 }
27381                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27382                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27383                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27385                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
27387                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
27388                 if (_ptr_local_machine) {
27389                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
27390                 } else {
27391                         r->in.local_machine = NULL;
27392                 }
27393                 if (r->in.local_machine) {
27394                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
27395                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
27396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
27397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
27398                         size_local_machine_1 = ndr_get_array_size(ndr, &r->in.local_machine);
27399                         length_local_machine_1 = ndr_get_array_length(ndr, &r->in.local_machine);
27400                         if (length_local_machine_1 > size_local_machine_1) {
27401                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_local_machine_1, length_local_machine_1);
27402                         }
27403                         NDR_CHECK(ndr_check_string_terminator(ndr, length_local_machine_1, sizeof(uint16_t)));
27404                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.local_machine, length_local_machine_1, sizeof(uint16_t), CH_UTF16));
27405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
27406                 }
27407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
27408                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
27409                 if (_ptr_notify_options) {
27410                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
27411                 } else {
27412                         r->in.notify_options = NULL;
27413                 }
27414                 if (r->in.notify_options) {
27415                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27416                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
27417                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27418                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
27419                 }
27420         }
27421         if (flags & NDR_OUT) {
27422                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27423         }
27424         return NDR_ERR_SUCCESS;
27425 }
27426
27427 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27428 {
27429         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27430         ndr->depth++;
27431         if (flags & NDR_SET_VALUES) {
27432                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27433         }
27434         if (flags & NDR_IN) {
27435                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27436                 ndr->depth++;
27437                 ndr_print_ptr(ndr, "handle", r->in.handle);
27438                 ndr->depth++;
27439                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27440                 ndr->depth--;
27441                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27442                 ndr_print_uint32(ndr, "options", r->in.options);
27443                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
27444                 ndr->depth++;
27445                 if (r->in.local_machine) {
27446                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
27447                 }
27448                 ndr->depth--;
27449                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27450                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
27451                 ndr->depth++;
27452                 if (r->in.notify_options) {
27453                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
27454                 }
27455                 ndr->depth--;
27456                 ndr->depth--;
27457         }
27458         if (flags & NDR_OUT) {
27459                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27460                 ndr->depth++;
27461                 ndr_print_WERROR(ndr, "result", r->out.result);
27462                 ndr->depth--;
27463         }
27464         ndr->depth--;
27465 }
27466
27467 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27468 {
27469         if (flags & NDR_IN) {
27470                 if (r->in.handle == NULL) {
27471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27472                 }
27473                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
27475                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
27477                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27478                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27479         }
27480         if (flags & NDR_OUT) {
27481                 if (r->out.reply_result == NULL) {
27482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27483                 }
27484                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
27485                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27486         }
27487         return NDR_ERR_SUCCESS;
27488 }
27489
27490 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
27491 {
27492         TALLOC_CTX *_mem_save_handle_0;
27493         TALLOC_CTX *_mem_save_reply_result_0;
27494         if (flags & NDR_IN) {
27495                 ZERO_STRUCT(r->out);
27496
27497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27498                         NDR_PULL_ALLOC(ndr, r->in.handle);
27499                 }
27500                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27501                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27502                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
27505                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
27507                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27508                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27509                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
27510                 ZERO_STRUCTP(r->out.reply_result);
27511         }
27512         if (flags & NDR_OUT) {
27513                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27514                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
27515                 }
27516                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
27517                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
27518                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
27519                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
27520                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27521         }
27522         return NDR_ERR_SUCCESS;
27523 }
27524
27525 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27526 {
27527         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
27528         ndr->depth++;
27529         if (flags & NDR_SET_VALUES) {
27530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27531         }
27532         if (flags & NDR_IN) {
27533                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
27534                 ndr->depth++;
27535                 ndr_print_ptr(ndr, "handle", r->in.handle);
27536                 ndr->depth++;
27537                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27538                 ndr->depth--;
27539                 ndr_print_uint32(ndr, "color", r->in.color);
27540                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27541                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
27542                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
27543                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
27544                 ndr->depth--;
27545         }
27546         if (flags & NDR_OUT) {
27547                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
27548                 ndr->depth++;
27549                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
27550                 ndr->depth++;
27551                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
27552                 ndr->depth--;
27553                 ndr_print_WERROR(ndr, "result", r->out.result);
27554                 ndr->depth--;
27555         }
27556         ndr->depth--;
27557 }
27558
27559 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27560 {
27561         if (flags & NDR_IN) {
27562                 if (r->in.handle == NULL) {
27563                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27564                 }
27565                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
27567                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
27568                 if (r->in.options) {
27569                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27570                 }
27571         }
27572         if (flags & NDR_OUT) {
27573                 if (r->out.info == NULL) {
27574                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27575                 }
27576                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
27577                 if (*r->out.info) {
27578                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27579                 }
27580                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27581         }
27582         return NDR_ERR_SUCCESS;
27583 }
27584
27585 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
27586 {
27587         uint32_t _ptr_options;
27588         uint32_t _ptr_info;
27589         TALLOC_CTX *_mem_save_handle_0;
27590         TALLOC_CTX *_mem_save_options_0;
27591         TALLOC_CTX *_mem_save_info_0;
27592         TALLOC_CTX *_mem_save_info_1;
27593         if (flags & NDR_IN) {
27594                 ZERO_STRUCT(r->out);
27595
27596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27597                         NDR_PULL_ALLOC(ndr, r->in.handle);
27598                 }
27599                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27600                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27601                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
27604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
27605                 if (_ptr_options) {
27606                         NDR_PULL_ALLOC(ndr, r->in.options);
27607                 } else {
27608                         r->in.options = NULL;
27609                 }
27610                 if (r->in.options) {
27611                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27612                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
27613                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
27615                 }
27616                 NDR_PULL_ALLOC(ndr, r->out.info);
27617                 ZERO_STRUCTP(r->out.info);
27618         }
27619         if (flags & NDR_OUT) {
27620                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27621                         NDR_PULL_ALLOC(ndr, r->out.info);
27622                 }
27623                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27624                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
27625                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
27626                 if (_ptr_info) {
27627                         NDR_PULL_ALLOC(ndr, *r->out.info);
27628                 } else {
27629                         *r->out.info = NULL;
27630                 }
27631                 if (*r->out.info) {
27632                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
27633                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
27634                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
27636                 }
27637                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
27638                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27639         }
27640         return NDR_ERR_SUCCESS;
27641 }
27642
27643 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27644 {
27645         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
27646         ndr->depth++;
27647         if (flags & NDR_SET_VALUES) {
27648                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27649         }
27650         if (flags & NDR_IN) {
27651                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
27652                 ndr->depth++;
27653                 ndr_print_ptr(ndr, "handle", r->in.handle);
27654                 ndr->depth++;
27655                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27656                 ndr->depth--;
27657                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
27658                 ndr_print_ptr(ndr, "options", r->in.options);
27659                 ndr->depth++;
27660                 if (r->in.options) {
27661                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27662                 }
27663                 ndr->depth--;
27664                 ndr->depth--;
27665         }
27666         if (flags & NDR_OUT) {
27667                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27668                 ndr->depth++;
27669                 ndr_print_ptr(ndr, "info", r->out.info);
27670                 ndr->depth++;
27671                 ndr_print_ptr(ndr, "info", *r->out.info);
27672                 ndr->depth++;
27673                 if (*r->out.info) {
27674                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27675                 }
27676                 ndr->depth--;
27677                 ndr->depth--;
27678                 ndr_print_WERROR(ndr, "result", r->out.result);
27679                 ndr->depth--;
27680         }
27681         ndr->depth--;
27682 }
27683
27684 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27685 {
27686         if (flags & NDR_IN) {
27687         }
27688         if (flags & NDR_OUT) {
27689                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27690         }
27691         return NDR_ERR_SUCCESS;
27692 }
27693
27694 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27695 {
27696         if (flags & NDR_IN) {
27697         }
27698         if (flags & NDR_OUT) {
27699                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27700         }
27701         return NDR_ERR_SUCCESS;
27702 }
27703
27704 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27705 {
27706         ndr_print_struct(ndr, name, "spoolss_44");
27707         ndr->depth++;
27708         if (flags & NDR_SET_VALUES) {
27709                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27710         }
27711         if (flags & NDR_IN) {
27712                 ndr_print_struct(ndr, "in", "spoolss_44");
27713                 ndr->depth++;
27714                 ndr->depth--;
27715         }
27716         if (flags & NDR_OUT) {
27717                 ndr_print_struct(ndr, "out", "spoolss_44");
27718                 ndr->depth++;
27719                 ndr_print_WERROR(ndr, "result", r->out.result);
27720                 ndr->depth--;
27721         }
27722         ndr->depth--;
27723 }
27724
27725 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27726 {
27727         if (flags & NDR_IN) {
27728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27729                 if (r->in.printername) {
27730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27731                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27732                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27734                 }
27735                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27736                 if (r->in.datatype) {
27737                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27738                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27740                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27741                 }
27742                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27743                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27745                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27746                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27747         }
27748         if (flags & NDR_OUT) {
27749                 if (r->out.handle == NULL) {
27750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27751                 }
27752                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27753                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27754         }
27755         return NDR_ERR_SUCCESS;
27756 }
27757
27758 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27759 {
27760         uint32_t _ptr_printername;
27761         uint32_t size_printername_1 = 0;
27762         uint32_t length_printername_1 = 0;
27763         uint32_t _ptr_datatype;
27764         uint32_t size_datatype_1 = 0;
27765         uint32_t length_datatype_1 = 0;
27766         TALLOC_CTX *_mem_save_printername_0;
27767         TALLOC_CTX *_mem_save_datatype_0;
27768         TALLOC_CTX *_mem_save_handle_0;
27769         if (flags & NDR_IN) {
27770                 ZERO_STRUCT(r->out);
27771
27772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27773                 if (_ptr_printername) {
27774                         NDR_PULL_ALLOC(ndr, r->in.printername);
27775                 } else {
27776                         r->in.printername = NULL;
27777                 }
27778                 if (r->in.printername) {
27779                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27780                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27781                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27782                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27783                         size_printername_1 = ndr_get_array_size(ndr, &r->in.printername);
27784                         length_printername_1 = ndr_get_array_length(ndr, &r->in.printername);
27785                         if (length_printername_1 > size_printername_1) {
27786                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_printername_1, length_printername_1);
27787                         }
27788                         NDR_CHECK(ndr_check_string_terminator(ndr, length_printername_1, sizeof(uint16_t)));
27789                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, length_printername_1, sizeof(uint16_t), CH_UTF16));
27790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27791                 }
27792                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27793                 if (_ptr_datatype) {
27794                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27795                 } else {
27796                         r->in.datatype = NULL;
27797                 }
27798                 if (r->in.datatype) {
27799                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27800                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27802                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27803                         size_datatype_1 = ndr_get_array_size(ndr, &r->in.datatype);
27804                         length_datatype_1 = ndr_get_array_length(ndr, &r->in.datatype);
27805                         if (length_datatype_1 > size_datatype_1) {
27806                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_datatype_1, length_datatype_1);
27807                         }
27808                         NDR_CHECK(ndr_check_string_terminator(ndr, length_datatype_1, sizeof(uint16_t)));
27809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, length_datatype_1, sizeof(uint16_t), CH_UTF16));
27810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27811                 }
27812                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27813                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27815                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27816                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27817                 NDR_PULL_ALLOC(ndr, r->out.handle);
27818                 ZERO_STRUCTP(r->out.handle);
27819         }
27820         if (flags & NDR_OUT) {
27821                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27822                         NDR_PULL_ALLOC(ndr, r->out.handle);
27823                 }
27824                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27825                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27826                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27828                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27829         }
27830         return NDR_ERR_SUCCESS;
27831 }
27832
27833 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27834 {
27835         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27836         ndr->depth++;
27837         if (flags & NDR_SET_VALUES) {
27838                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27839         }
27840         if (flags & NDR_IN) {
27841                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27842                 ndr->depth++;
27843                 ndr_print_ptr(ndr, "printername", r->in.printername);
27844                 ndr->depth++;
27845                 if (r->in.printername) {
27846                         ndr_print_string(ndr, "printername", r->in.printername);
27847                 }
27848                 ndr->depth--;
27849                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27850                 ndr->depth++;
27851                 if (r->in.datatype) {
27852                         ndr_print_string(ndr, "datatype", r->in.datatype);
27853                 }
27854                 ndr->depth--;
27855                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27856                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27857                 ndr_print_uint32(ndr, "level", r->in.level);
27858                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27859                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27860                 ndr->depth--;
27861         }
27862         if (flags & NDR_OUT) {
27863                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27864                 ndr->depth++;
27865                 ndr_print_ptr(ndr, "handle", r->out.handle);
27866                 ndr->depth++;
27867                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27868                 ndr->depth--;
27869                 ndr_print_WERROR(ndr, "result", r->out.result);
27870                 ndr->depth--;
27871         }
27872         ndr->depth--;
27873 }
27874
27875 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27876 {
27877         if (flags & NDR_IN) {
27878                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27879                 if (r->in.server) {
27880                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27881                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27883                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27884                 }
27885                 if (r->in.info_ctr == NULL) {
27886                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27887                 }
27888                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27889                 if (r->in.devmode_ctr == NULL) {
27890                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27891                 }
27892                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27893                 if (r->in.secdesc_ctr == NULL) {
27894                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27895                 }
27896                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27897                 if (r->in.userlevel_ctr == NULL) {
27898                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27899                 }
27900                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27901         }
27902         if (flags & NDR_OUT) {
27903                 if (r->out.handle == NULL) {
27904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27905                 }
27906                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27907                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27908         }
27909         return NDR_ERR_SUCCESS;
27910 }
27911
27912 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27913 {
27914         uint32_t _ptr_server;
27915         uint32_t size_server_1 = 0;
27916         uint32_t length_server_1 = 0;
27917         TALLOC_CTX *_mem_save_server_0;
27918         TALLOC_CTX *_mem_save_info_ctr_0;
27919         TALLOC_CTX *_mem_save_devmode_ctr_0;
27920         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27921         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27922         TALLOC_CTX *_mem_save_handle_0;
27923         if (flags & NDR_IN) {
27924                 ZERO_STRUCT(r->out);
27925
27926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27927                 if (_ptr_server) {
27928                         NDR_PULL_ALLOC(ndr, r->in.server);
27929                 } else {
27930                         r->in.server = NULL;
27931                 }
27932                 if (r->in.server) {
27933                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27934                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27937                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
27938                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
27939                         if (length_server_1 > size_server_1) {
27940                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
27941                         }
27942                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
27943                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
27944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27945                 }
27946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27947                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27948                 }
27949                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27950                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27951                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27954                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27955                 }
27956                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27957                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27958                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27961                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27962                 }
27963                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27964                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27965                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27967                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27968                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27969                 }
27970                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27971                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27972                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27973                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27974                 NDR_PULL_ALLOC(ndr, r->out.handle);
27975                 ZERO_STRUCTP(r->out.handle);
27976         }
27977         if (flags & NDR_OUT) {
27978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27979                         NDR_PULL_ALLOC(ndr, r->out.handle);
27980                 }
27981                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27982                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27983                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27985                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27986         }
27987         return NDR_ERR_SUCCESS;
27988 }
27989
27990 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27991 {
27992         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27993         ndr->depth++;
27994         if (flags & NDR_SET_VALUES) {
27995                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27996         }
27997         if (flags & NDR_IN) {
27998                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27999                 ndr->depth++;
28000                 ndr_print_ptr(ndr, "server", r->in.server);
28001                 ndr->depth++;
28002                 if (r->in.server) {
28003                         ndr_print_string(ndr, "server", r->in.server);
28004                 }
28005                 ndr->depth--;
28006                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28007                 ndr->depth++;
28008                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28009                 ndr->depth--;
28010                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
28011                 ndr->depth++;
28012                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
28013                 ndr->depth--;
28014                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
28015                 ndr->depth++;
28016                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
28017                 ndr->depth--;
28018                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
28019                 ndr->depth++;
28020                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
28021                 ndr->depth--;
28022                 ndr->depth--;
28023         }
28024         if (flags & NDR_OUT) {
28025                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
28026                 ndr->depth++;
28027                 ndr_print_ptr(ndr, "handle", r->out.handle);
28028                 ndr->depth++;
28029                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
28030                 ndr->depth--;
28031                 ndr_print_WERROR(ndr, "result", r->out.result);
28032                 ndr->depth--;
28033         }
28034         ndr->depth--;
28035 }
28036
28037 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
28038 {
28039         if (flags & NDR_IN) {
28040         }
28041         if (flags & NDR_OUT) {
28042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28043         }
28044         return NDR_ERR_SUCCESS;
28045 }
28046
28047 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
28048 {
28049         if (flags & NDR_IN) {
28050         }
28051         if (flags & NDR_OUT) {
28052                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28053         }
28054         return NDR_ERR_SUCCESS;
28055 }
28056
28057 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
28058 {
28059         ndr_print_struct(ndr, name, "spoolss_47");
28060         ndr->depth++;
28061         if (flags & NDR_SET_VALUES) {
28062                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28063         }
28064         if (flags & NDR_IN) {
28065                 ndr_print_struct(ndr, "in", "spoolss_47");
28066                 ndr->depth++;
28067                 ndr->depth--;
28068         }
28069         if (flags & NDR_OUT) {
28070                 ndr_print_struct(ndr, "out", "spoolss_47");
28071                 ndr->depth++;
28072                 ndr_print_WERROR(ndr, "result", r->out.result);
28073                 ndr->depth--;
28074         }
28075         ndr->depth--;
28076 }
28077
28078 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
28079 {
28080         if (flags & NDR_IN) {
28081                 if (r->in.handle == NULL) {
28082                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28083                 }
28084                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
28086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
28087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
28088         }
28089         if (flags & NDR_OUT) {
28090                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
28091                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
28092                 if (r->out.value_needed == NULL) {
28093                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28094                 }
28095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
28096                 if (r->out.type == NULL) {
28097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28098                 }
28099                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28100                 {
28101                         uint32_t _flags_save_uint8 = ndr->flags;
28102                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
28103                         if (r->out.data == NULL) {
28104                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28105                         }
28106                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
28107                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
28108                         ndr->flags = _flags_save_uint8;
28109                 }
28110                 if (r->out.data_needed == NULL) {
28111                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28112                 }
28113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
28114                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28115         }
28116         return NDR_ERR_SUCCESS;
28117 }
28118
28119 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
28120 {
28121         uint32_t size_value_name_0 = 0;
28122         uint32_t size_data_1 = 0;
28123         TALLOC_CTX *_mem_save_handle_0;
28124         TALLOC_CTX *_mem_save_value_needed_0;
28125         TALLOC_CTX *_mem_save_type_0;
28126         TALLOC_CTX *_mem_save_data_needed_0;
28127         if (flags & NDR_IN) {
28128                 ZERO_STRUCT(r->out);
28129
28130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28131                         NDR_PULL_ALLOC(ndr, r->in.handle);
28132                 }
28133                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28134                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28135                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
28138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
28139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
28140                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
28141                 ZERO_STRUCTP(r->out.value_needed);
28142                 NDR_PULL_ALLOC(ndr, r->out.type);
28143                 ZERO_STRUCTP(r->out.type);
28144                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
28145                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
28146                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
28147                 ZERO_STRUCTP(r->out.data_needed);
28148         }
28149         if (flags & NDR_OUT) {
28150                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
28151                 size_value_name_0 = ndr_get_array_size(ndr, &r->out.value_name);
28152                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.value_name, size_value_name_0, sizeof(uint16_t), CH_UTF16));
28153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28154                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
28155                 }
28156                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28157                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
28158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
28159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
28160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28161                         NDR_PULL_ALLOC(ndr, r->out.type);
28162                 }
28163                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28164                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28165                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28167                 {
28168                         uint32_t _flags_save_uint8 = ndr->flags;
28169                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
28170                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
28171                         size_data_1 = ndr_get_array_size(ndr, &r->out.data);
28172                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28173                                 NDR_PULL_ALLOC_N(ndr, r->out.data, size_data_1);
28174                         }
28175                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, size_data_1));
28176                         ndr->flags = _flags_save_uint8;
28177                 }
28178                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28179                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
28180                 }
28181                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28182                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
28183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
28184                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
28185                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28186                 if (r->out.value_name) {
28187                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
28188                 }
28189                 if (r->out.data) {
28190                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
28191                 }
28192         }
28193         return NDR_ERR_SUCCESS;
28194 }
28195
28196 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
28197 {
28198         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
28199         ndr->depth++;
28200         if (flags & NDR_SET_VALUES) {
28201                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28202         }
28203         if (flags & NDR_IN) {
28204                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
28205                 ndr->depth++;
28206                 ndr_print_ptr(ndr, "handle", r->in.handle);
28207                 ndr->depth++;
28208                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28209                 ndr->depth--;
28210                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
28211                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
28212                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
28213                 ndr->depth--;
28214         }
28215         if (flags & NDR_OUT) {
28216                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
28217                 ndr->depth++;
28218                 ndr_print_string(ndr, "value_name", r->out.value_name);
28219                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
28220                 ndr->depth++;
28221                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
28222                 ndr->depth--;
28223                 ndr_print_ptr(ndr, "type", r->out.type);
28224                 ndr->depth++;
28225                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28226                 ndr->depth--;
28227                 ndr_print_ptr(ndr, "data", r->out.data);
28228                 ndr->depth++;
28229                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
28230                 ndr->depth--;
28231                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
28232                 ndr->depth++;
28233                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
28234                 ndr->depth--;
28235                 ndr_print_WERROR(ndr, "result", r->out.result);
28236                 ndr->depth--;
28237         }
28238         ndr->depth--;
28239 }
28240
28241 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
28242 {
28243         if (flags & NDR_IN) {
28244                 if (r->in.handle == NULL) {
28245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28246                 }
28247                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28248                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28249                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28250                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28251                 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));
28252         }
28253         if (flags & NDR_OUT) {
28254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28255         }
28256         return NDR_ERR_SUCCESS;
28257 }
28258
28259 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
28260 {
28261         uint32_t size_value_name_0 = 0;
28262         uint32_t length_value_name_0 = 0;
28263         TALLOC_CTX *_mem_save_handle_0;
28264         if (flags & NDR_IN) {
28265                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28266                         NDR_PULL_ALLOC(ndr, r->in.handle);
28267                 }
28268                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28269                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28270                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28271                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28272                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28273                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28274                 size_value_name_0 = ndr_get_array_size(ndr, &r->in.value_name);
28275                 length_value_name_0 = ndr_get_array_length(ndr, &r->in.value_name);
28276                 if (length_value_name_0 > size_value_name_0) {
28277                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_value_name_0, length_value_name_0);
28278                 }
28279                 NDR_CHECK(ndr_check_string_terminator(ndr, length_value_name_0, sizeof(uint16_t)));
28280                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, length_value_name_0, sizeof(uint16_t), CH_UTF16));
28281         }
28282         if (flags & NDR_OUT) {
28283                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28284         }
28285         return NDR_ERR_SUCCESS;
28286 }
28287
28288 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
28289 {
28290         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
28291         ndr->depth++;
28292         if (flags & NDR_SET_VALUES) {
28293                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28294         }
28295         if (flags & NDR_IN) {
28296                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
28297                 ndr->depth++;
28298                 ndr_print_ptr(ndr, "handle", r->in.handle);
28299                 ndr->depth++;
28300                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28301                 ndr->depth--;
28302                 ndr_print_string(ndr, "value_name", r->in.value_name);
28303                 ndr->depth--;
28304         }
28305         if (flags & NDR_OUT) {
28306                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
28307                 ndr->depth++;
28308                 ndr_print_WERROR(ndr, "result", r->out.result);
28309                 ndr->depth--;
28310         }
28311         ndr->depth--;
28312 }
28313
28314 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
28315 {
28316         if (flags & NDR_IN) {
28317         }
28318         if (flags & NDR_OUT) {
28319                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28320         }
28321         return NDR_ERR_SUCCESS;
28322 }
28323
28324 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
28325 {
28326         if (flags & NDR_IN) {
28327         }
28328         if (flags & NDR_OUT) {
28329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28330         }
28331         return NDR_ERR_SUCCESS;
28332 }
28333
28334 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
28335 {
28336         ndr_print_struct(ndr, name, "spoolss_4a");
28337         ndr->depth++;
28338         if (flags & NDR_SET_VALUES) {
28339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28340         }
28341         if (flags & NDR_IN) {
28342                 ndr_print_struct(ndr, "in", "spoolss_4a");
28343                 ndr->depth++;
28344                 ndr->depth--;
28345         }
28346         if (flags & NDR_OUT) {
28347                 ndr_print_struct(ndr, "out", "spoolss_4a");
28348                 ndr->depth++;
28349                 ndr_print_WERROR(ndr, "result", r->out.result);
28350                 ndr->depth--;
28351         }
28352         ndr->depth--;
28353 }
28354
28355 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
28356 {
28357         if (flags & NDR_IN) {
28358         }
28359         if (flags & NDR_OUT) {
28360                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28361         }
28362         return NDR_ERR_SUCCESS;
28363 }
28364
28365 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
28366 {
28367         if (flags & NDR_IN) {
28368         }
28369         if (flags & NDR_OUT) {
28370                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28371         }
28372         return NDR_ERR_SUCCESS;
28373 }
28374
28375 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
28376 {
28377         ndr_print_struct(ndr, name, "spoolss_4b");
28378         ndr->depth++;
28379         if (flags & NDR_SET_VALUES) {
28380                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28381         }
28382         if (flags & NDR_IN) {
28383                 ndr_print_struct(ndr, "in", "spoolss_4b");
28384                 ndr->depth++;
28385                 ndr->depth--;
28386         }
28387         if (flags & NDR_OUT) {
28388                 ndr_print_struct(ndr, "out", "spoolss_4b");
28389                 ndr->depth++;
28390                 ndr_print_WERROR(ndr, "result", r->out.result);
28391                 ndr->depth--;
28392         }
28393         ndr->depth--;
28394 }
28395
28396 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
28397 {
28398         if (flags & NDR_IN) {
28399         }
28400         if (flags & NDR_OUT) {
28401                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28402         }
28403         return NDR_ERR_SUCCESS;
28404 }
28405
28406 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
28407 {
28408         if (flags & NDR_IN) {
28409         }
28410         if (flags & NDR_OUT) {
28411                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28412         }
28413         return NDR_ERR_SUCCESS;
28414 }
28415
28416 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
28417 {
28418         ndr_print_struct(ndr, name, "spoolss_4c");
28419         ndr->depth++;
28420         if (flags & NDR_SET_VALUES) {
28421                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28422         }
28423         if (flags & NDR_IN) {
28424                 ndr_print_struct(ndr, "in", "spoolss_4c");
28425                 ndr->depth++;
28426                 ndr->depth--;
28427         }
28428         if (flags & NDR_OUT) {
28429                 ndr_print_struct(ndr, "out", "spoolss_4c");
28430                 ndr->depth++;
28431                 ndr_print_WERROR(ndr, "result", r->out.result);
28432                 ndr->depth--;
28433         }
28434         ndr->depth--;
28435 }
28436
28437 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
28438 {
28439         if (flags & NDR_IN) {
28440                 if (r->in.handle == NULL) {
28441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28442                 }
28443                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28444                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28445                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28446                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28447                 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));
28448                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28449                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28450                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28451                 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));
28452                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28453                 if (r->in.data == NULL) {
28454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28455                 }
28456                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
28457                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.offered));
28458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28459         }
28460         if (flags & NDR_OUT) {
28461                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28462         }
28463         return NDR_ERR_SUCCESS;
28464 }
28465
28466 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
28467 {
28468         uint32_t size_key_name_0 = 0;
28469         uint32_t length_key_name_0 = 0;
28470         uint32_t size_value_name_0 = 0;
28471         uint32_t length_value_name_0 = 0;
28472         uint32_t size_data_1 = 0;
28473         TALLOC_CTX *_mem_save_handle_0;
28474         if (flags & NDR_IN) {
28475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28476                         NDR_PULL_ALLOC(ndr, r->in.handle);
28477                 }
28478                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28479                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28480                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28482                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28483                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28484                 size_key_name_0 = ndr_get_array_size(ndr, &r->in.key_name);
28485                 length_key_name_0 = ndr_get_array_length(ndr, &r->in.key_name);
28486                 if (length_key_name_0 > size_key_name_0) {
28487                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_key_name_0, length_key_name_0);
28488                 }
28489                 NDR_CHECK(ndr_check_string_terminator(ndr, length_key_name_0, sizeof(uint16_t)));
28490                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, length_key_name_0, sizeof(uint16_t), CH_UTF16));
28491                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28492                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28493                 size_value_name_0 = ndr_get_array_size(ndr, &r->in.value_name);
28494                 length_value_name_0 = ndr_get_array_length(ndr, &r->in.value_name);
28495                 if (length_value_name_0 > size_value_name_0) {
28496                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_value_name_0, length_value_name_0);
28497                 }
28498                 NDR_CHECK(ndr_check_string_terminator(ndr, length_value_name_0, sizeof(uint16_t)));
28499                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, length_value_name_0, sizeof(uint16_t), CH_UTF16));
28500                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28501                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
28502                 size_data_1 = ndr_get_array_size(ndr, &r->in.data);
28503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28504                         NDR_PULL_ALLOC_N(ndr, r->in.data, size_data_1);
28505                 }
28506                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, size_data_1));
28507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28508                 if (r->in.data) {
28509                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.offered));
28510                 }
28511         }
28512         if (flags & NDR_OUT) {
28513                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28514         }
28515         return NDR_ERR_SUCCESS;
28516 }
28517
28518 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
28519 {
28520         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
28521         ndr->depth++;
28522         if (flags & NDR_SET_VALUES) {
28523                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28524         }
28525         if (flags & NDR_IN) {
28526                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
28527                 ndr->depth++;
28528                 ndr_print_ptr(ndr, "handle", r->in.handle);
28529                 ndr->depth++;
28530                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28531                 ndr->depth--;
28532                 ndr_print_string(ndr, "key_name", r->in.key_name);
28533                 ndr_print_string(ndr, "value_name", r->in.value_name);
28534                 ndr_print_winreg_Type(ndr, "type", r->in.type);
28535                 ndr_print_ptr(ndr, "data", r->in.data);
28536                 ndr->depth++;
28537                 ndr_print_array_uint8(ndr, "data", r->in.data, r->in.offered);
28538                 ndr->depth--;
28539                 ndr_print_uint32(ndr, "offered", r->in.offered);
28540                 ndr->depth--;
28541         }
28542         if (flags & NDR_OUT) {
28543                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
28544                 ndr->depth++;
28545                 ndr_print_WERROR(ndr, "result", r->out.result);
28546                 ndr->depth--;
28547         }
28548         ndr->depth--;
28549 }
28550
28551 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
28552 {
28553         if (flags & NDR_IN) {
28554                 if (r->in.handle == NULL) {
28555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28556                 }
28557                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28558                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28559                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28560                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28561                 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));
28562                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28563                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28564                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28565                 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));
28566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28567         }
28568         if (flags & NDR_OUT) {
28569                 if (r->out.type == NULL) {
28570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28571                 }
28572                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28573                 if (r->out.data == NULL) {
28574                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28575                 }
28576                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
28577                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.offered));
28578                 if (r->out.needed == NULL) {
28579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28580                 }
28581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28582                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28583         }
28584         return NDR_ERR_SUCCESS;
28585 }
28586
28587 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
28588 {
28589         uint32_t size_key_name_0 = 0;
28590         uint32_t length_key_name_0 = 0;
28591         uint32_t size_value_name_0 = 0;
28592         uint32_t length_value_name_0 = 0;
28593         uint32_t size_data_1 = 0;
28594         TALLOC_CTX *_mem_save_handle_0;
28595         TALLOC_CTX *_mem_save_type_0;
28596         TALLOC_CTX *_mem_save_needed_0;
28597         if (flags & NDR_IN) {
28598                 ZERO_STRUCT(r->out);
28599
28600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28601                         NDR_PULL_ALLOC(ndr, r->in.handle);
28602                 }
28603                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28604                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28605                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28607                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28608                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28609                 size_key_name_0 = ndr_get_array_size(ndr, &r->in.key_name);
28610                 length_key_name_0 = ndr_get_array_length(ndr, &r->in.key_name);
28611                 if (length_key_name_0 > size_key_name_0) {
28612                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_key_name_0, length_key_name_0);
28613                 }
28614                 NDR_CHECK(ndr_check_string_terminator(ndr, length_key_name_0, sizeof(uint16_t)));
28615                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, length_key_name_0, sizeof(uint16_t), CH_UTF16));
28616                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28617                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28618                 size_value_name_0 = ndr_get_array_size(ndr, &r->in.value_name);
28619                 length_value_name_0 = ndr_get_array_length(ndr, &r->in.value_name);
28620                 if (length_value_name_0 > size_value_name_0) {
28621                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_value_name_0, length_value_name_0);
28622                 }
28623                 NDR_CHECK(ndr_check_string_terminator(ndr, length_value_name_0, sizeof(uint16_t)));
28624                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, length_value_name_0, sizeof(uint16_t), CH_UTF16));
28625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28626                 NDR_PULL_ALLOC(ndr, r->out.type);
28627                 ZERO_STRUCTP(r->out.type);
28628                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.offered);
28629                 memset(r->out.data, 0, (r->in.offered) * sizeof(*r->out.data));
28630                 NDR_PULL_ALLOC(ndr, r->out.needed);
28631                 ZERO_STRUCTP(r->out.needed);
28632         }
28633         if (flags & NDR_OUT) {
28634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28635                         NDR_PULL_ALLOC(ndr, r->out.type);
28636                 }
28637                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28638                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28639                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28641                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
28642                 size_data_1 = ndr_get_array_size(ndr, &r->out.data);
28643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28644                         NDR_PULL_ALLOC_N(ndr, r->out.data, size_data_1);
28645                 }
28646                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, size_data_1));
28647                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28648                         NDR_PULL_ALLOC(ndr, r->out.needed);
28649                 }
28650                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28651                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28653                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28655                 if (r->out.data) {
28656                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.offered));
28657                 }
28658         }
28659         return NDR_ERR_SUCCESS;
28660 }
28661
28662 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
28663 {
28664         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
28665         ndr->depth++;
28666         if (flags & NDR_SET_VALUES) {
28667                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28668         }
28669         if (flags & NDR_IN) {
28670                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
28671                 ndr->depth++;
28672                 ndr_print_ptr(ndr, "handle", r->in.handle);
28673                 ndr->depth++;
28674                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28675                 ndr->depth--;
28676                 ndr_print_string(ndr, "key_name", r->in.key_name);
28677                 ndr_print_string(ndr, "value_name", r->in.value_name);
28678                 ndr_print_uint32(ndr, "offered", r->in.offered);
28679                 ndr->depth--;
28680         }
28681         if (flags & NDR_OUT) {
28682                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
28683                 ndr->depth++;
28684                 ndr_print_ptr(ndr, "type", r->out.type);
28685                 ndr->depth++;
28686                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28687                 ndr->depth--;
28688                 ndr_print_ptr(ndr, "data", r->out.data);
28689                 ndr->depth++;
28690                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.offered);
28691                 ndr->depth--;
28692                 ndr_print_ptr(ndr, "needed", r->out.needed);
28693                 ndr->depth++;
28694                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28695                 ndr->depth--;
28696                 ndr_print_WERROR(ndr, "result", r->out.result);
28697                 ndr->depth--;
28698         }
28699         ndr->depth--;
28700 }
28701
28702 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28703 {
28704         if (flags & NDR_IN) {
28705                 if (r->in.handle == NULL) {
28706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28707                 }
28708                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28709                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28710                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28711                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28712                 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));
28713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28714         }
28715         if (flags & NDR_OUT) {
28716                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28717                 if (r->out.needed == NULL) {
28718                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28719                 }
28720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28721                 if (r->out.count == NULL) {
28722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28723                 }
28724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28725                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28726         }
28727         return NDR_ERR_SUCCESS;
28728 }
28729
28730 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28731 {
28732         uint32_t size_key_name_0 = 0;
28733         uint32_t length_key_name_0 = 0;
28734         TALLOC_CTX *_mem_save_handle_0;
28735         TALLOC_CTX *_mem_save_needed_0;
28736         TALLOC_CTX *_mem_save_count_0;
28737         if (flags & NDR_IN) {
28738                 ZERO_STRUCT(r->out);
28739
28740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28741                         NDR_PULL_ALLOC(ndr, r->in.handle);
28742                 }
28743                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28745                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28747                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28748                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28749                 size_key_name_0 = ndr_get_array_size(ndr, &r->in.key_name);
28750                 length_key_name_0 = ndr_get_array_length(ndr, &r->in.key_name);
28751                 if (length_key_name_0 > size_key_name_0) {
28752                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_key_name_0, length_key_name_0);
28753                 }
28754                 NDR_CHECK(ndr_check_string_terminator(ndr, length_key_name_0, sizeof(uint16_t)));
28755                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, length_key_name_0, sizeof(uint16_t), CH_UTF16));
28756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28757                 NDR_PULL_ALLOC(ndr, r->out.needed);
28758                 ZERO_STRUCTP(r->out.needed);
28759                 NDR_PULL_ALLOC(ndr, r->out.count);
28760                 ZERO_STRUCTP(r->out.count);
28761         }
28762         if (flags & NDR_OUT) {
28763                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28764                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28765                         NDR_PULL_ALLOC(ndr, r->out.needed);
28766                 }
28767                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28768                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28770                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28771                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28772                         NDR_PULL_ALLOC(ndr, r->out.count);
28773                 }
28774                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28775                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28777                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28778                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28779         }
28780         return NDR_ERR_SUCCESS;
28781 }
28782
28783 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28784 {
28785         uint32_t cntr_info_0;
28786         if (flags & NDR_IN) {
28787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28788         }
28789         if (flags & NDR_OUT) {
28790                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28791                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28792                 }
28793                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28794                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28795                 }
28796         }
28797         return NDR_ERR_SUCCESS;
28798 }
28799
28800 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28801 {
28802         uint32_t size_info_0 = 0;
28803         uint32_t cntr_info_0;
28804         TALLOC_CTX *_mem_save_info_0;
28805         if (flags & NDR_IN) {
28806                 ZERO_STRUCT(r->out);
28807
28808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28809         }
28810         if (flags & NDR_OUT) {
28811                 size_info_0 = r->in.count;
28812                 NDR_PULL_ALLOC_N(ndr, r->out.info, size_info_0);
28813                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28814                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28815                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
28816                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28817                 }
28818                 for (cntr_info_0 = 0; cntr_info_0 < size_info_0; cntr_info_0++) {
28819                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28820                 }
28821                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28822         }
28823         return NDR_ERR_SUCCESS;
28824 }
28825
28826 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28827 {
28828         uint32_t cntr_info_2;
28829         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28830         ndr->depth++;
28831         if (flags & NDR_SET_VALUES) {
28832                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28833         }
28834         if (flags & NDR_IN) {
28835                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28836                 ndr->depth++;
28837                 ndr_print_ptr(ndr, "handle", r->in.handle);
28838                 ndr->depth++;
28839                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28840                 ndr->depth--;
28841                 ndr_print_string(ndr, "key_name", r->in.key_name);
28842                 ndr_print_uint32(ndr, "offered", r->in.offered);
28843                 ndr->depth--;
28844         }
28845         if (flags & NDR_OUT) {
28846                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28847                 ndr->depth++;
28848                 ndr_print_ptr(ndr, "count", r->out.count);
28849                 ndr->depth++;
28850                 ndr_print_uint32(ndr, "count", *r->out.count);
28851                 ndr->depth--;
28852                 ndr_print_ptr(ndr, "info", r->out.info);
28853                 ndr->depth++;
28854                 ndr_print_ptr(ndr, "info", *r->out.info);
28855                 ndr->depth++;
28856                 if (*r->out.info) {
28857                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28858                         ndr->depth++;
28859                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28860                                 char *idx_2=NULL;
28861                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28862                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28863                                         free(idx_2);
28864                                 }
28865                         }
28866                         ndr->depth--;
28867                 }
28868                 ndr->depth--;
28869                 ndr->depth--;
28870                 ndr_print_ptr(ndr, "needed", r->out.needed);
28871                 ndr->depth++;
28872                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28873                 ndr->depth--;
28874                 ndr_print_WERROR(ndr, "result", r->out.result);
28875                 ndr->depth--;
28876         }
28877         ndr->depth--;
28878 }
28879
28880 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28881 {
28882         if (flags & NDR_IN) {
28883                 if (r->in.handle == NULL) {
28884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28885                 }
28886                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28887                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28888                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28889                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28890                 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));
28891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28892         }
28893         if (flags & NDR_OUT) {
28894                 if (r->out._ndr_size == NULL) {
28895                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28896                 }
28897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28898                 if (r->out.key_buffer == NULL) {
28899                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28900                 }
28901                 {
28902                         struct ndr_push *_ndr_key_buffer;
28903                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28904                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28905                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28906                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28907                 }
28908                 if (r->out.needed == NULL) {
28909                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28910                 }
28911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28912                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28913         }
28914         return NDR_ERR_SUCCESS;
28915 }
28916
28917 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28918 {
28919         uint32_t size_key_name_0 = 0;
28920         uint32_t length_key_name_0 = 0;
28921         TALLOC_CTX *_mem_save_handle_0;
28922         TALLOC_CTX *_mem_save__ndr_size_0;
28923         TALLOC_CTX *_mem_save_key_buffer_0;
28924         TALLOC_CTX *_mem_save_needed_0;
28925         if (flags & NDR_IN) {
28926                 ZERO_STRUCT(r->out);
28927
28928                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28929                         NDR_PULL_ALLOC(ndr, r->in.handle);
28930                 }
28931                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28932                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28933                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28934                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28935                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28936                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28937                 size_key_name_0 = ndr_get_array_size(ndr, &r->in.key_name);
28938                 length_key_name_0 = ndr_get_array_length(ndr, &r->in.key_name);
28939                 if (length_key_name_0 > size_key_name_0) {
28940                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_key_name_0, length_key_name_0);
28941                 }
28942                 NDR_CHECK(ndr_check_string_terminator(ndr, length_key_name_0, sizeof(uint16_t)));
28943                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, length_key_name_0, sizeof(uint16_t), CH_UTF16));
28944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28945                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28946                 ZERO_STRUCTP(r->out._ndr_size);
28947                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28948                 ZERO_STRUCTP(r->out.key_buffer);
28949                 NDR_PULL_ALLOC(ndr, r->out.needed);
28950                 ZERO_STRUCTP(r->out.needed);
28951         }
28952         if (flags & NDR_OUT) {
28953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28954                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28955                 }
28956                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
28957                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
28958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
28959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
28960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28961                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28962                 }
28963                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
28964                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
28965                 {
28966                         struct ndr_pull *_ndr_key_buffer;
28967                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28968                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28969                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28970                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28971                 }
28972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
28973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28974                         NDR_PULL_ALLOC(ndr, r->out.needed);
28975                 }
28976                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28977                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28980                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28981         }
28982         return NDR_ERR_SUCCESS;
28983 }
28984
28985 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28986 {
28987         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28988         ndr->depth++;
28989         if (flags & NDR_SET_VALUES) {
28990                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28991         }
28992         if (flags & NDR_IN) {
28993                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28994                 ndr->depth++;
28995                 ndr_print_ptr(ndr, "handle", r->in.handle);
28996                 ndr->depth++;
28997                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28998                 ndr->depth--;
28999                 ndr_print_string(ndr, "key_name", r->in.key_name);
29000                 ndr_print_uint32(ndr, "offered", r->in.offered);
29001                 ndr->depth--;
29002         }
29003         if (flags & NDR_OUT) {
29004                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
29005                 ndr->depth++;
29006                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
29007                 ndr->depth++;
29008                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
29009                 ndr->depth--;
29010                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
29011                 ndr->depth++;
29012                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
29013                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
29014                 ndr->depth--;
29015                 ndr_print_ptr(ndr, "needed", r->out.needed);
29016                 ndr->depth++;
29017                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29018                 ndr->depth--;
29019                 ndr_print_WERROR(ndr, "result", r->out.result);
29020                 ndr->depth--;
29021         }
29022         ndr->depth--;
29023 }
29024
29025 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
29026 {
29027         if (flags & NDR_IN) {
29028                 if (r->in.handle == NULL) {
29029                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29030                 }
29031                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29032                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29033                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29034                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29035                 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));
29036                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
29037                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29038                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
29039                 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));
29040         }
29041         if (flags & NDR_OUT) {
29042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29043         }
29044         return NDR_ERR_SUCCESS;
29045 }
29046
29047 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
29048 {
29049         uint32_t size_key_name_0 = 0;
29050         uint32_t length_key_name_0 = 0;
29051         uint32_t size_value_name_0 = 0;
29052         uint32_t length_value_name_0 = 0;
29053         TALLOC_CTX *_mem_save_handle_0;
29054         if (flags & NDR_IN) {
29055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29056                         NDR_PULL_ALLOC(ndr, r->in.handle);
29057                 }
29058                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29059                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29060                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29062                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
29063                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
29064                 size_key_name_0 = ndr_get_array_size(ndr, &r->in.key_name);
29065                 length_key_name_0 = ndr_get_array_length(ndr, &r->in.key_name);
29066                 if (length_key_name_0 > size_key_name_0) {
29067                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_key_name_0, length_key_name_0);
29068                 }
29069                 NDR_CHECK(ndr_check_string_terminator(ndr, length_key_name_0, sizeof(uint16_t)));
29070                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, length_key_name_0, sizeof(uint16_t), CH_UTF16));
29071                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
29072                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
29073                 size_value_name_0 = ndr_get_array_size(ndr, &r->in.value_name);
29074                 length_value_name_0 = ndr_get_array_length(ndr, &r->in.value_name);
29075                 if (length_value_name_0 > size_value_name_0) {
29076                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_value_name_0, length_value_name_0);
29077                 }
29078                 NDR_CHECK(ndr_check_string_terminator(ndr, length_value_name_0, sizeof(uint16_t)));
29079                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, length_value_name_0, sizeof(uint16_t), CH_UTF16));
29080         }
29081         if (flags & NDR_OUT) {
29082                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29083         }
29084         return NDR_ERR_SUCCESS;
29085 }
29086
29087 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
29088 {
29089         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
29090         ndr->depth++;
29091         if (flags & NDR_SET_VALUES) {
29092                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29093         }
29094         if (flags & NDR_IN) {
29095                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
29096                 ndr->depth++;
29097                 ndr_print_ptr(ndr, "handle", r->in.handle);
29098                 ndr->depth++;
29099                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29100                 ndr->depth--;
29101                 ndr_print_string(ndr, "key_name", r->in.key_name);
29102                 ndr_print_string(ndr, "value_name", r->in.value_name);
29103                 ndr->depth--;
29104         }
29105         if (flags & NDR_OUT) {
29106                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
29107                 ndr->depth++;
29108                 ndr_print_WERROR(ndr, "result", r->out.result);
29109                 ndr->depth--;
29110         }
29111         ndr->depth--;
29112 }
29113
29114 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
29115 {
29116         if (flags & NDR_IN) {
29117                 if (r->in.handle == NULL) {
29118                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29119                 }
29120                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29121                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29122                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29123                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29124                 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));
29125         }
29126         if (flags & NDR_OUT) {
29127                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29128         }
29129         return NDR_ERR_SUCCESS;
29130 }
29131
29132 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
29133 {
29134         uint32_t size_key_name_0 = 0;
29135         uint32_t length_key_name_0 = 0;
29136         TALLOC_CTX *_mem_save_handle_0;
29137         if (flags & NDR_IN) {
29138                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29139                         NDR_PULL_ALLOC(ndr, r->in.handle);
29140                 }
29141                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29142                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29143                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29145                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
29146                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
29147                 size_key_name_0 = ndr_get_array_size(ndr, &r->in.key_name);
29148                 length_key_name_0 = ndr_get_array_length(ndr, &r->in.key_name);
29149                 if (length_key_name_0 > size_key_name_0) {
29150                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_key_name_0, length_key_name_0);
29151                 }
29152                 NDR_CHECK(ndr_check_string_terminator(ndr, length_key_name_0, sizeof(uint16_t)));
29153                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, length_key_name_0, sizeof(uint16_t), CH_UTF16));
29154         }
29155         if (flags & NDR_OUT) {
29156                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29157         }
29158         return NDR_ERR_SUCCESS;
29159 }
29160
29161 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
29162 {
29163         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
29164         ndr->depth++;
29165         if (flags & NDR_SET_VALUES) {
29166                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29167         }
29168         if (flags & NDR_IN) {
29169                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
29170                 ndr->depth++;
29171                 ndr_print_ptr(ndr, "handle", r->in.handle);
29172                 ndr->depth++;
29173                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29174                 ndr->depth--;
29175                 ndr_print_string(ndr, "key_name", r->in.key_name);
29176                 ndr->depth--;
29177         }
29178         if (flags & NDR_OUT) {
29179                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
29180                 ndr->depth++;
29181                 ndr_print_WERROR(ndr, "result", r->out.result);
29182                 ndr->depth--;
29183         }
29184         ndr->depth--;
29185 }
29186
29187 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
29188 {
29189         if (flags & NDR_IN) {
29190         }
29191         if (flags & NDR_OUT) {
29192                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29193         }
29194         return NDR_ERR_SUCCESS;
29195 }
29196
29197 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
29198 {
29199         if (flags & NDR_IN) {
29200         }
29201         if (flags & NDR_OUT) {
29202                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29203         }
29204         return NDR_ERR_SUCCESS;
29205 }
29206
29207 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
29208 {
29209         ndr_print_struct(ndr, name, "spoolss_53");
29210         ndr->depth++;
29211         if (flags & NDR_SET_VALUES) {
29212                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29213         }
29214         if (flags & NDR_IN) {
29215                 ndr_print_struct(ndr, "in", "spoolss_53");
29216                 ndr->depth++;
29217                 ndr->depth--;
29218         }
29219         if (flags & NDR_OUT) {
29220                 ndr_print_struct(ndr, "out", "spoolss_53");
29221                 ndr->depth++;
29222                 ndr_print_WERROR(ndr, "result", r->out.result);
29223                 ndr->depth--;
29224         }
29225         ndr->depth--;
29226 }
29227
29228 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
29229 {
29230         if (flags & NDR_IN) {
29231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
29232                 if (r->in.server) {
29233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
29234                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29235                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
29236                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29237                 }
29238                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29239                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29240                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29241                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29242                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
29243                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29244                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
29245                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29246                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
29247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
29248         }
29249         if (flags & NDR_OUT) {
29250                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29251         }
29252         return NDR_ERR_SUCCESS;
29253 }
29254
29255 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
29256 {
29257         uint32_t _ptr_server;
29258         uint32_t size_server_1 = 0;
29259         uint32_t length_server_1 = 0;
29260         uint32_t size_architecture_0 = 0;
29261         uint32_t length_architecture_0 = 0;
29262         uint32_t size_driver_0 = 0;
29263         uint32_t length_driver_0 = 0;
29264         TALLOC_CTX *_mem_save_server_0;
29265         if (flags & NDR_IN) {
29266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
29267                 if (_ptr_server) {
29268                         NDR_PULL_ALLOC(ndr, r->in.server);
29269                 } else {
29270                         r->in.server = NULL;
29271                 }
29272                 if (r->in.server) {
29273                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
29274                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
29275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
29276                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
29277                         size_server_1 = ndr_get_array_size(ndr, &r->in.server);
29278                         length_server_1 = ndr_get_array_length(ndr, &r->in.server);
29279                         if (length_server_1 > size_server_1) {
29280                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_1, length_server_1);
29281                         }
29282                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_1, sizeof(uint16_t)));
29283                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, length_server_1, sizeof(uint16_t), CH_UTF16));
29284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
29285                 }
29286                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29287                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29288                 size_architecture_0 = ndr_get_array_size(ndr, &r->in.architecture);
29289                 length_architecture_0 = ndr_get_array_length(ndr, &r->in.architecture);
29290                 if (length_architecture_0 > size_architecture_0) {
29291                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_0, length_architecture_0);
29292                 }
29293                 NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_0, sizeof(uint16_t)));
29294                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, length_architecture_0, sizeof(uint16_t), CH_UTF16));
29295                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
29296                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
29297                 size_driver_0 = ndr_get_array_size(ndr, &r->in.driver);
29298                 length_driver_0 = ndr_get_array_length(ndr, &r->in.driver);
29299                 if (length_driver_0 > size_driver_0) {
29300                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_driver_0, length_driver_0);
29301                 }
29302                 NDR_CHECK(ndr_check_string_terminator(ndr, length_driver_0, sizeof(uint16_t)));
29303                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, length_driver_0, sizeof(uint16_t), CH_UTF16));
29304                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
29305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
29306         }
29307         if (flags & NDR_OUT) {
29308                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29309         }
29310         return NDR_ERR_SUCCESS;
29311 }
29312
29313 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
29314 {
29315         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
29316         ndr->depth++;
29317         if (flags & NDR_SET_VALUES) {
29318                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29319         }
29320         if (flags & NDR_IN) {
29321                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
29322                 ndr->depth++;
29323                 ndr_print_ptr(ndr, "server", r->in.server);
29324                 ndr->depth++;
29325                 if (r->in.server) {
29326                         ndr_print_string(ndr, "server", r->in.server);
29327                 }
29328                 ndr->depth--;
29329                 ndr_print_string(ndr, "architecture", r->in.architecture);
29330                 ndr_print_string(ndr, "driver", r->in.driver);
29331                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
29332                 ndr_print_uint32(ndr, "version", r->in.version);
29333                 ndr->depth--;
29334         }
29335         if (flags & NDR_OUT) {
29336                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
29337                 ndr->depth++;
29338                 ndr_print_WERROR(ndr, "result", r->out.result);
29339                 ndr->depth--;
29340         }
29341         ndr->depth--;
29342 }
29343
29344 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
29345 {
29346         if (flags & NDR_IN) {
29347         }
29348         if (flags & NDR_OUT) {
29349                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29350         }
29351         return NDR_ERR_SUCCESS;
29352 }
29353
29354 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
29355 {
29356         if (flags & NDR_IN) {
29357         }
29358         if (flags & NDR_OUT) {
29359                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29360         }
29361         return NDR_ERR_SUCCESS;
29362 }
29363
29364 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
29365 {
29366         ndr_print_struct(ndr, name, "spoolss_55");
29367         ndr->depth++;
29368         if (flags & NDR_SET_VALUES) {
29369                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29370         }
29371         if (flags & NDR_IN) {
29372                 ndr_print_struct(ndr, "in", "spoolss_55");
29373                 ndr->depth++;
29374                 ndr->depth--;
29375         }
29376         if (flags & NDR_OUT) {
29377                 ndr_print_struct(ndr, "out", "spoolss_55");
29378                 ndr->depth++;
29379                 ndr_print_WERROR(ndr, "result", r->out.result);
29380                 ndr->depth--;
29381         }
29382         ndr->depth--;
29383 }
29384
29385 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
29386 {
29387         if (flags & NDR_IN) {
29388         }
29389         if (flags & NDR_OUT) {
29390                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29391         }
29392         return NDR_ERR_SUCCESS;
29393 }
29394
29395 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
29396 {
29397         if (flags & NDR_IN) {
29398         }
29399         if (flags & NDR_OUT) {
29400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29401         }
29402         return NDR_ERR_SUCCESS;
29403 }
29404
29405 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
29406 {
29407         ndr_print_struct(ndr, name, "spoolss_56");
29408         ndr->depth++;
29409         if (flags & NDR_SET_VALUES) {
29410                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29411         }
29412         if (flags & NDR_IN) {
29413                 ndr_print_struct(ndr, "in", "spoolss_56");
29414                 ndr->depth++;
29415                 ndr->depth--;
29416         }
29417         if (flags & NDR_OUT) {
29418                 ndr_print_struct(ndr, "out", "spoolss_56");
29419                 ndr->depth++;
29420                 ndr_print_WERROR(ndr, "result", r->out.result);
29421                 ndr->depth--;
29422         }
29423         ndr->depth--;
29424 }
29425
29426 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
29427 {
29428         if (flags & NDR_IN) {
29429         }
29430         if (flags & NDR_OUT) {
29431                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29432         }
29433         return NDR_ERR_SUCCESS;
29434 }
29435
29436 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
29437 {
29438         if (flags & NDR_IN) {
29439         }
29440         if (flags & NDR_OUT) {
29441                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29442         }
29443         return NDR_ERR_SUCCESS;
29444 }
29445
29446 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
29447 {
29448         ndr_print_struct(ndr, name, "spoolss_57");
29449         ndr->depth++;
29450         if (flags & NDR_SET_VALUES) {
29451                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29452         }
29453         if (flags & NDR_IN) {
29454                 ndr_print_struct(ndr, "in", "spoolss_57");
29455                 ndr->depth++;
29456                 ndr->depth--;
29457         }
29458         if (flags & NDR_OUT) {
29459                 ndr_print_struct(ndr, "out", "spoolss_57");
29460                 ndr->depth++;
29461                 ndr_print_WERROR(ndr, "result", r->out.result);
29462                 ndr->depth--;
29463         }
29464         ndr->depth--;
29465 }
29466
29467 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
29468 {
29469         if (flags & NDR_IN) {
29470                 if (r->in.handle == NULL) {
29471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29472                 }
29473                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29474                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29475                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29476                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29477                 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));
29478                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
29479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
29480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
29481                 if (r->in.status_code == NULL) {
29482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29483                 }
29484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
29485         }
29486         if (flags & NDR_OUT) {
29487                 if (r->out.out_data == NULL) {
29488                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29489                 }
29490                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
29491                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
29492                 if (r->out.needed == NULL) {
29493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29494                 }
29495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
29496                 if (r->out.status_code == NULL) {
29497                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29498                 }
29499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
29500                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29501         }
29502         return NDR_ERR_SUCCESS;
29503 }
29504
29505 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
29506 {
29507         uint32_t size_function_name_0 = 0;
29508         uint32_t length_function_name_0 = 0;
29509         uint32_t size_out_data_1 = 0;
29510         TALLOC_CTX *_mem_save_handle_0;
29511         TALLOC_CTX *_mem_save_needed_0;
29512         TALLOC_CTX *_mem_save_status_code_0;
29513         if (flags & NDR_IN) {
29514                 ZERO_STRUCT(r->out);
29515
29516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29517                         NDR_PULL_ALLOC(ndr, r->in.handle);
29518                 }
29519                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29520                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29521                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29522                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29523                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
29524                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
29525                 size_function_name_0 = ndr_get_array_size(ndr, &r->in.function_name);
29526                 length_function_name_0 = ndr_get_array_length(ndr, &r->in.function_name);
29527                 if (length_function_name_0 > size_function_name_0) {
29528                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_function_name_0, length_function_name_0);
29529                 }
29530                 NDR_CHECK(ndr_check_string_terminator(ndr, length_function_name_0, sizeof(uint16_t)));
29531                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.function_name, length_function_name_0, sizeof(uint16_t), CH_UTF16));
29532                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
29533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
29534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
29535                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29536                         NDR_PULL_ALLOC(ndr, r->in.status_code);
29537                 }
29538                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29539                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
29540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
29541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29542                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
29543                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
29544                 NDR_PULL_ALLOC(ndr, r->out.needed);
29545                 ZERO_STRUCTP(r->out.needed);
29546                 NDR_PULL_ALLOC(ndr, r->out.status_code);
29547                 *r->out.status_code = *r->in.status_code;
29548         }
29549         if (flags & NDR_OUT) {
29550                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
29551                 size_out_data_1 = ndr_get_array_size(ndr, &r->out.out_data);
29552                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29553                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, size_out_data_1);
29554                 }
29555                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, size_out_data_1));
29556                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29557                         NDR_PULL_ALLOC(ndr, r->out.needed);
29558                 }
29559                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29560                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29562                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29564                         NDR_PULL_ALLOC(ndr, r->out.status_code);
29565                 }
29566                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29567                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
29568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
29569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29570                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29571                 if (r->out.out_data) {
29572                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
29573                 }
29574         }
29575         return NDR_ERR_SUCCESS;
29576 }
29577
29578 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
29579 {
29580         ndr_print_struct(ndr, name, "spoolss_XcvData");
29581         ndr->depth++;
29582         if (flags & NDR_SET_VALUES) {
29583                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29584         }
29585         if (flags & NDR_IN) {
29586                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
29587                 ndr->depth++;
29588                 ndr_print_ptr(ndr, "handle", r->in.handle);
29589                 ndr->depth++;
29590                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29591                 ndr->depth--;
29592                 ndr_print_string(ndr, "function_name", r->in.function_name);
29593                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
29594                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
29595                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
29596                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
29597                 ndr->depth++;
29598                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
29599                 ndr->depth--;
29600                 ndr->depth--;
29601         }
29602         if (flags & NDR_OUT) {
29603                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
29604                 ndr->depth++;
29605                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
29606                 ndr->depth++;
29607                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
29608                 ndr->depth--;
29609                 ndr_print_ptr(ndr, "needed", r->out.needed);
29610                 ndr->depth++;
29611                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29612                 ndr->depth--;
29613                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
29614                 ndr->depth++;
29615                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
29616                 ndr->depth--;
29617                 ndr_print_WERROR(ndr, "result", r->out.result);
29618                 ndr->depth--;
29619         }
29620         ndr->depth--;
29621 }
29622
29623 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
29624 {
29625         if (flags & NDR_IN) {
29626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29627                 if (r->in.servername) {
29628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29631                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29632                 }
29633                 if (r->in.info_ctr == NULL) {
29634                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29635                 }
29636                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29637                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
29638         }
29639         if (flags & NDR_OUT) {
29640                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29641         }
29642         return NDR_ERR_SUCCESS;
29643 }
29644
29645 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
29646 {
29647         uint32_t _ptr_servername;
29648         uint32_t size_servername_1 = 0;
29649         uint32_t length_servername_1 = 0;
29650         TALLOC_CTX *_mem_save_servername_0;
29651         TALLOC_CTX *_mem_save_info_ctr_0;
29652         if (flags & NDR_IN) {
29653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29654                 if (_ptr_servername) {
29655                         NDR_PULL_ALLOC(ndr, r->in.servername);
29656                 } else {
29657                         r->in.servername = NULL;
29658                 }
29659                 if (r->in.servername) {
29660                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29661                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29662                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29663                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29664                         size_servername_1 = ndr_get_array_size(ndr, &r->in.servername);
29665                         length_servername_1 = ndr_get_array_length(ndr, &r->in.servername);
29666                         if (length_servername_1 > size_servername_1) {
29667                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
29668                         }
29669                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
29670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
29671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29672                 }
29673                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29674                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
29675                 }
29676                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
29677                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
29678                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29679                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
29680                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
29681         }
29682         if (flags & NDR_OUT) {
29683                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29684         }
29685         return NDR_ERR_SUCCESS;
29686 }
29687
29688 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
29689 {
29690         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
29691         ndr->depth++;
29692         if (flags & NDR_SET_VALUES) {
29693                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29694         }
29695         if (flags & NDR_IN) {
29696                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
29697                 ndr->depth++;
29698                 ndr_print_ptr(ndr, "servername", r->in.servername);
29699                 ndr->depth++;
29700                 if (r->in.servername) {
29701                         ndr_print_string(ndr, "servername", r->in.servername);
29702                 }
29703                 ndr->depth--;
29704                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
29705                 ndr->depth++;
29706                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
29707                 ndr->depth--;
29708                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
29709                 ndr->depth--;
29710         }
29711         if (flags & NDR_OUT) {
29712                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
29713                 ndr->depth++;
29714                 ndr_print_WERROR(ndr, "result", r->out.result);
29715                 ndr->depth--;
29716         }
29717         ndr->depth--;
29718 }
29719
29720 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
29721 {
29722         if (flags & NDR_IN) {
29723         }
29724         if (flags & NDR_OUT) {
29725                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29726         }
29727         return NDR_ERR_SUCCESS;
29728 }
29729
29730 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29731 {
29732         if (flags & NDR_IN) {
29733         }
29734         if (flags & NDR_OUT) {
29735                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29736         }
29737         return NDR_ERR_SUCCESS;
29738 }
29739
29740 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29741 {
29742         ndr_print_struct(ndr, name, "spoolss_5a");
29743         ndr->depth++;
29744         if (flags & NDR_SET_VALUES) {
29745                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29746         }
29747         if (flags & NDR_IN) {
29748                 ndr_print_struct(ndr, "in", "spoolss_5a");
29749                 ndr->depth++;
29750                 ndr->depth--;
29751         }
29752         if (flags & NDR_OUT) {
29753                 ndr_print_struct(ndr, "out", "spoolss_5a");
29754                 ndr->depth++;
29755                 ndr_print_WERROR(ndr, "result", r->out.result);
29756                 ndr->depth--;
29757         }
29758         ndr->depth--;
29759 }
29760
29761 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29762 {
29763         if (flags & NDR_IN) {
29764         }
29765         if (flags & NDR_OUT) {
29766                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29767         }
29768         return NDR_ERR_SUCCESS;
29769 }
29770
29771 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29772 {
29773         if (flags & NDR_IN) {
29774         }
29775         if (flags & NDR_OUT) {
29776                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29777         }
29778         return NDR_ERR_SUCCESS;
29779 }
29780
29781 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29782 {
29783         ndr_print_struct(ndr, name, "spoolss_5b");
29784         ndr->depth++;
29785         if (flags & NDR_SET_VALUES) {
29786                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29787         }
29788         if (flags & NDR_IN) {
29789                 ndr_print_struct(ndr, "in", "spoolss_5b");
29790                 ndr->depth++;
29791                 ndr->depth--;
29792         }
29793         if (flags & NDR_OUT) {
29794                 ndr_print_struct(ndr, "out", "spoolss_5b");
29795                 ndr->depth++;
29796                 ndr_print_WERROR(ndr, "result", r->out.result);
29797                 ndr->depth--;
29798         }
29799         ndr->depth--;
29800 }
29801
29802 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29803 {
29804         if (flags & NDR_IN) {
29805         }
29806         if (flags & NDR_OUT) {
29807                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29808         }
29809         return NDR_ERR_SUCCESS;
29810 }
29811
29812 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29813 {
29814         if (flags & NDR_IN) {
29815         }
29816         if (flags & NDR_OUT) {
29817                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29818         }
29819         return NDR_ERR_SUCCESS;
29820 }
29821
29822 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29823 {
29824         ndr_print_struct(ndr, name, "spoolss_5c");
29825         ndr->depth++;
29826         if (flags & NDR_SET_VALUES) {
29827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29828         }
29829         if (flags & NDR_IN) {
29830                 ndr_print_struct(ndr, "in", "spoolss_5c");
29831                 ndr->depth++;
29832                 ndr->depth--;
29833         }
29834         if (flags & NDR_OUT) {
29835                 ndr_print_struct(ndr, "out", "spoolss_5c");
29836                 ndr->depth++;
29837                 ndr_print_WERROR(ndr, "result", r->out.result);
29838                 ndr->depth--;
29839         }
29840         ndr->depth--;
29841 }
29842
29843 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29844 {
29845         if (flags & NDR_IN) {
29846         }
29847         if (flags & NDR_OUT) {
29848                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29849         }
29850         return NDR_ERR_SUCCESS;
29851 }
29852
29853 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29854 {
29855         if (flags & NDR_IN) {
29856         }
29857         if (flags & NDR_OUT) {
29858                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29859         }
29860         return NDR_ERR_SUCCESS;
29861 }
29862
29863 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29864 {
29865         ndr_print_struct(ndr, name, "spoolss_5d");
29866         ndr->depth++;
29867         if (flags & NDR_SET_VALUES) {
29868                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29869         }
29870         if (flags & NDR_IN) {
29871                 ndr_print_struct(ndr, "in", "spoolss_5d");
29872                 ndr->depth++;
29873                 ndr->depth--;
29874         }
29875         if (flags & NDR_OUT) {
29876                 ndr_print_struct(ndr, "out", "spoolss_5d");
29877                 ndr->depth++;
29878                 ndr_print_WERROR(ndr, "result", r->out.result);
29879                 ndr->depth--;
29880         }
29881         ndr->depth--;
29882 }
29883
29884 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29885 {
29886         if (flags & NDR_IN) {
29887         }
29888         if (flags & NDR_OUT) {
29889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29890         }
29891         return NDR_ERR_SUCCESS;
29892 }
29893
29894 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29895 {
29896         if (flags & NDR_IN) {
29897         }
29898         if (flags & NDR_OUT) {
29899                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29900         }
29901         return NDR_ERR_SUCCESS;
29902 }
29903
29904 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29905 {
29906         ndr_print_struct(ndr, name, "spoolss_5e");
29907         ndr->depth++;
29908         if (flags & NDR_SET_VALUES) {
29909                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29910         }
29911         if (flags & NDR_IN) {
29912                 ndr_print_struct(ndr, "in", "spoolss_5e");
29913                 ndr->depth++;
29914                 ndr->depth--;
29915         }
29916         if (flags & NDR_OUT) {
29917                 ndr_print_struct(ndr, "out", "spoolss_5e");
29918                 ndr->depth++;
29919                 ndr_print_WERROR(ndr, "result", r->out.result);
29920                 ndr->depth--;
29921         }
29922         ndr->depth--;
29923 }
29924
29925 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29926 {
29927         if (flags & NDR_IN) {
29928         }
29929         if (flags & NDR_OUT) {
29930                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29931         }
29932         return NDR_ERR_SUCCESS;
29933 }
29934
29935 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29936 {
29937         if (flags & NDR_IN) {
29938         }
29939         if (flags & NDR_OUT) {
29940                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29941         }
29942         return NDR_ERR_SUCCESS;
29943 }
29944
29945 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29946 {
29947         ndr_print_struct(ndr, name, "spoolss_5f");
29948         ndr->depth++;
29949         if (flags & NDR_SET_VALUES) {
29950                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29951         }
29952         if (flags & NDR_IN) {
29953                 ndr_print_struct(ndr, "in", "spoolss_5f");
29954                 ndr->depth++;
29955                 ndr->depth--;
29956         }
29957         if (flags & NDR_OUT) {
29958                 ndr_print_struct(ndr, "out", "spoolss_5f");
29959                 ndr->depth++;
29960                 ndr_print_WERROR(ndr, "result", r->out.result);
29961                 ndr->depth--;
29962         }
29963         ndr->depth--;
29964 }
29965
29966 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29967 {
29968         if (flags & NDR_IN) {
29969         }
29970         if (flags & NDR_OUT) {
29971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29972         }
29973         return NDR_ERR_SUCCESS;
29974 }
29975
29976 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29977 {
29978         if (flags & NDR_IN) {
29979         }
29980         if (flags & NDR_OUT) {
29981                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29982         }
29983         return NDR_ERR_SUCCESS;
29984 }
29985
29986 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29987 {
29988         ndr_print_struct(ndr, name, "spoolss_60");
29989         ndr->depth++;
29990         if (flags & NDR_SET_VALUES) {
29991                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29992         }
29993         if (flags & NDR_IN) {
29994                 ndr_print_struct(ndr, "in", "spoolss_60");
29995                 ndr->depth++;
29996                 ndr->depth--;
29997         }
29998         if (flags & NDR_OUT) {
29999                 ndr_print_struct(ndr, "out", "spoolss_60");
30000                 ndr->depth++;
30001                 ndr_print_WERROR(ndr, "result", r->out.result);
30002                 ndr->depth--;
30003         }
30004         ndr->depth--;
30005 }
30006
30007 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
30008 {
30009         if (flags & NDR_IN) {
30010         }
30011         if (flags & NDR_OUT) {
30012                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30013         }
30014         return NDR_ERR_SUCCESS;
30015 }
30016
30017 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
30018 {
30019         if (flags & NDR_IN) {
30020         }
30021         if (flags & NDR_OUT) {
30022                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30023         }
30024         return NDR_ERR_SUCCESS;
30025 }
30026
30027 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
30028 {
30029         ndr_print_struct(ndr, name, "spoolss_61");
30030         ndr->depth++;
30031         if (flags & NDR_SET_VALUES) {
30032                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30033         }
30034         if (flags & NDR_IN) {
30035                 ndr_print_struct(ndr, "in", "spoolss_61");
30036                 ndr->depth++;
30037                 ndr->depth--;
30038         }
30039         if (flags & NDR_OUT) {
30040                 ndr_print_struct(ndr, "out", "spoolss_61");
30041                 ndr->depth++;
30042                 ndr_print_WERROR(ndr, "result", r->out.result);
30043                 ndr->depth--;
30044         }
30045         ndr->depth--;
30046 }
30047
30048 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
30049 {
30050         if (flags & NDR_IN) {
30051         }
30052         if (flags & NDR_OUT) {
30053                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30054         }
30055         return NDR_ERR_SUCCESS;
30056 }
30057
30058 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
30059 {
30060         if (flags & NDR_IN) {
30061         }
30062         if (flags & NDR_OUT) {
30063                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30064         }
30065         return NDR_ERR_SUCCESS;
30066 }
30067
30068 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
30069 {
30070         ndr_print_struct(ndr, name, "spoolss_62");
30071         ndr->depth++;
30072         if (flags & NDR_SET_VALUES) {
30073                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30074         }
30075         if (flags & NDR_IN) {
30076                 ndr_print_struct(ndr, "in", "spoolss_62");
30077                 ndr->depth++;
30078                 ndr->depth--;
30079         }
30080         if (flags & NDR_OUT) {
30081                 ndr_print_struct(ndr, "out", "spoolss_62");
30082                 ndr->depth++;
30083                 ndr_print_WERROR(ndr, "result", r->out.result);
30084                 ndr->depth--;
30085         }
30086         ndr->depth--;
30087 }
30088
30089 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
30090 {
30091         if (flags & NDR_IN) {
30092         }
30093         if (flags & NDR_OUT) {
30094                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30095         }
30096         return NDR_ERR_SUCCESS;
30097 }
30098
30099 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
30100 {
30101         if (flags & NDR_IN) {
30102         }
30103         if (flags & NDR_OUT) {
30104                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30105         }
30106         return NDR_ERR_SUCCESS;
30107 }
30108
30109 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
30110 {
30111         ndr_print_struct(ndr, name, "spoolss_63");
30112         ndr->depth++;
30113         if (flags & NDR_SET_VALUES) {
30114                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30115         }
30116         if (flags & NDR_IN) {
30117                 ndr_print_struct(ndr, "in", "spoolss_63");
30118                 ndr->depth++;
30119                 ndr->depth--;
30120         }
30121         if (flags & NDR_OUT) {
30122                 ndr_print_struct(ndr, "out", "spoolss_63");
30123                 ndr->depth++;
30124                 ndr_print_WERROR(ndr, "result", r->out.result);
30125                 ndr->depth--;
30126         }
30127         ndr->depth--;
30128 }
30129
30130 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
30131 {
30132         if (flags & NDR_IN) {
30133         }
30134         if (flags & NDR_OUT) {
30135                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30136         }
30137         return NDR_ERR_SUCCESS;
30138 }
30139
30140 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
30141 {
30142         if (flags & NDR_IN) {
30143         }
30144         if (flags & NDR_OUT) {
30145                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30146         }
30147         return NDR_ERR_SUCCESS;
30148 }
30149
30150 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
30151 {
30152         ndr_print_struct(ndr, name, "spoolss_64");
30153         ndr->depth++;
30154         if (flags & NDR_SET_VALUES) {
30155                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30156         }
30157         if (flags & NDR_IN) {
30158                 ndr_print_struct(ndr, "in", "spoolss_64");
30159                 ndr->depth++;
30160                 ndr->depth--;
30161         }
30162         if (flags & NDR_OUT) {
30163                 ndr_print_struct(ndr, "out", "spoolss_64");
30164                 ndr->depth++;
30165                 ndr_print_WERROR(ndr, "result", r->out.result);
30166                 ndr->depth--;
30167         }
30168         ndr->depth--;
30169 }
30170
30171 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
30172 {
30173         if (flags & NDR_IN) {
30174         }
30175         if (flags & NDR_OUT) {
30176                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30177         }
30178         return NDR_ERR_SUCCESS;
30179 }
30180
30181 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
30182 {
30183         if (flags & NDR_IN) {
30184         }
30185         if (flags & NDR_OUT) {
30186                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30187         }
30188         return NDR_ERR_SUCCESS;
30189 }
30190
30191 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
30192 {
30193         ndr_print_struct(ndr, name, "spoolss_65");
30194         ndr->depth++;
30195         if (flags & NDR_SET_VALUES) {
30196                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30197         }
30198         if (flags & NDR_IN) {
30199                 ndr_print_struct(ndr, "in", "spoolss_65");
30200                 ndr->depth++;
30201                 ndr->depth--;
30202         }
30203         if (flags & NDR_OUT) {
30204                 ndr_print_struct(ndr, "out", "spoolss_65");
30205                 ndr->depth++;
30206                 ndr_print_WERROR(ndr, "result", r->out.result);
30207                 ndr->depth--;
30208         }
30209         ndr->depth--;
30210 }
30211
30212 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
30213 {
30214         uint32_t cntr_core_printer_drivers_1;
30215         if (flags & NDR_IN) {
30216                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30217                 if (r->in.servername) {
30218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30220                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30221                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30222                 }
30223                 if (r->in.architecture == NULL) {
30224                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30225                 }
30226                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30227                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30228                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30229                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
30231                 if (r->in.core_driver_dependencies == NULL) {
30232                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30233                 }
30234                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
30235                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
30236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
30237         }
30238         if (flags & NDR_OUT) {
30239                 if (r->out.core_printer_drivers == NULL) {
30240                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30241                 }
30242                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
30243                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
30244                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
30245                 }
30246                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30247         }
30248         return NDR_ERR_SUCCESS;
30249 }
30250
30251 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
30252 {
30253         uint32_t _ptr_servername;
30254         uint32_t size_servername_1 = 0;
30255         uint32_t length_servername_1 = 0;
30256         uint32_t size_architecture_1 = 0;
30257         uint32_t length_architecture_1 = 0;
30258         uint32_t size_core_driver_dependencies_1 = 0;
30259         uint32_t size_core_printer_drivers_1 = 0;
30260         uint32_t cntr_core_printer_drivers_1;
30261         TALLOC_CTX *_mem_save_servername_0;
30262         TALLOC_CTX *_mem_save_core_printer_drivers_1;
30263         if (flags & NDR_IN) {
30264                 ZERO_STRUCT(r->out);
30265
30266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30267                 if (_ptr_servername) {
30268                         NDR_PULL_ALLOC(ndr, r->in.servername);
30269                 } else {
30270                         r->in.servername = NULL;
30271                 }
30272                 if (r->in.servername) {
30273                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30274                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30276                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30277                         size_servername_1 = ndr_get_array_size(ndr, &r->in.servername);
30278                         length_servername_1 = ndr_get_array_length(ndr, &r->in.servername);
30279                         if (length_servername_1 > size_servername_1) {
30280                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
30281                         }
30282                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
30283                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
30284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30285                 }
30286                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30287                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30288                 size_architecture_1 = ndr_get_array_size(ndr, &r->in.architecture);
30289                 length_architecture_1 = ndr_get_array_length(ndr, &r->in.architecture);
30290                 if (length_architecture_1 > size_architecture_1) {
30291                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
30292                 }
30293                 NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
30294                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
30295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
30296                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
30297                 size_core_driver_dependencies_1 = ndr_get_array_size(ndr, &r->in.core_driver_dependencies);
30298                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.core_driver_dependencies, size_core_driver_dependencies_1, sizeof(uint16_t), CH_UTF16));
30299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
30300                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
30301                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
30302                 if (r->in.core_driver_dependencies) {
30303                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
30304                 }
30305         }
30306         if (flags & NDR_OUT) {
30307                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
30308                 size_core_printer_drivers_1 = ndr_get_array_size(ndr, &r->out.core_printer_drivers);
30309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30310                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, size_core_printer_drivers_1);
30311                 }
30312                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
30313                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
30314                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < size_core_printer_drivers_1; cntr_core_printer_drivers_1++) {
30315                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
30316                 }
30317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
30318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30319                 if (r->out.core_printer_drivers) {
30320                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
30321                 }
30322         }
30323         return NDR_ERR_SUCCESS;
30324 }
30325
30326 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
30327 {
30328         uint32_t cntr_core_printer_drivers_1;
30329         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
30330         ndr->depth++;
30331         if (flags & NDR_SET_VALUES) {
30332                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30333         }
30334         if (flags & NDR_IN) {
30335                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
30336                 ndr->depth++;
30337                 ndr_print_ptr(ndr, "servername", r->in.servername);
30338                 ndr->depth++;
30339                 if (r->in.servername) {
30340                         ndr_print_string(ndr, "servername", r->in.servername);
30341                 }
30342                 ndr->depth--;
30343                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30344                 ndr->depth++;
30345                 ndr_print_string(ndr, "architecture", r->in.architecture);
30346                 ndr->depth--;
30347                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
30348                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30349                 ndr->depth++;
30350                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30351                 ndr->depth--;
30352                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
30353                 ndr->depth--;
30354         }
30355         if (flags & NDR_OUT) {
30356                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
30357                 ndr->depth++;
30358                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
30359                 ndr->depth++;
30360                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
30361                 ndr->depth++;
30362                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
30363                         char *idx_1=NULL;
30364                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
30365                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
30366                                 free(idx_1);
30367                         }
30368                 }
30369                 ndr->depth--;
30370                 ndr->depth--;
30371                 ndr_print_WERROR(ndr, "result", r->out.result);
30372                 ndr->depth--;
30373         }
30374         ndr->depth--;
30375 }
30376
30377 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
30378 {
30379         if (flags & NDR_IN) {
30380         }
30381         if (flags & NDR_OUT) {
30382                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30383         }
30384         return NDR_ERR_SUCCESS;
30385 }
30386
30387 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
30388 {
30389         if (flags & NDR_IN) {
30390         }
30391         if (flags & NDR_OUT) {
30392                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30393         }
30394         return NDR_ERR_SUCCESS;
30395 }
30396
30397 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
30398 {
30399         ndr_print_struct(ndr, name, "spoolss_67");
30400         ndr->depth++;
30401         if (flags & NDR_SET_VALUES) {
30402                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30403         }
30404         if (flags & NDR_IN) {
30405                 ndr_print_struct(ndr, "in", "spoolss_67");
30406                 ndr->depth++;
30407                 ndr->depth--;
30408         }
30409         if (flags & NDR_OUT) {
30410                 ndr_print_struct(ndr, "out", "spoolss_67");
30411                 ndr->depth++;
30412                 ndr_print_WERROR(ndr, "result", r->out.result);
30413                 ndr->depth--;
30414         }
30415         ndr->depth--;
30416 }
30417
30418 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30419 {
30420         if (flags & NDR_IN) {
30421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30422                 if (r->in.servername) {
30423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30426                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30427                 }
30428                 if (r->in.architecture == NULL) {
30429                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30430                 }
30431                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30432                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30433                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30434                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30435                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
30436                 if (r->in.language) {
30437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30441                 }
30442                 if (r->in.package_id == NULL) {
30443                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30444                 }
30445                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30446                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30447                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30448                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.package_id, ndr_charset_length(r->in.package_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
30450                 if (r->in.driver_package_cab) {
30451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30453                 }
30454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30455         }
30456         if (flags & NDR_OUT) {
30457                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
30458                 if (r->out.driver_package_cab) {
30459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30461                 }
30462                 if (r->out.required == NULL) {
30463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30464                 }
30465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
30466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30467         }
30468         return NDR_ERR_SUCCESS;
30469 }
30470
30471 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
30472 {
30473         uint32_t _ptr_servername;
30474         uint32_t size_servername_1 = 0;
30475         uint32_t length_servername_1 = 0;
30476         uint32_t size_architecture_1 = 0;
30477         uint32_t length_architecture_1 = 0;
30478         uint32_t _ptr_language;
30479         uint32_t size_language_1 = 0;
30480         uint32_t length_language_1 = 0;
30481         uint32_t size_package_id_1 = 0;
30482         uint32_t length_package_id_1 = 0;
30483         uint32_t _ptr_driver_package_cab;
30484         uint32_t size_driver_package_cab_1 = 0;
30485         TALLOC_CTX *_mem_save_servername_0;
30486         TALLOC_CTX *_mem_save_language_0;
30487         TALLOC_CTX *_mem_save_driver_package_cab_0;
30488         TALLOC_CTX *_mem_save_required_0;
30489         if (flags & NDR_IN) {
30490                 ZERO_STRUCT(r->out);
30491
30492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30493                 if (_ptr_servername) {
30494                         NDR_PULL_ALLOC(ndr, r->in.servername);
30495                 } else {
30496                         r->in.servername = NULL;
30497                 }
30498                 if (r->in.servername) {
30499                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30500                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30501                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30502                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30503                         size_servername_1 = ndr_get_array_size(ndr, &r->in.servername);
30504                         length_servername_1 = ndr_get_array_length(ndr, &r->in.servername);
30505                         if (length_servername_1 > size_servername_1) {
30506                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_servername_1, length_servername_1);
30507                         }
30508                         NDR_CHECK(ndr_check_string_terminator(ndr, length_servername_1, sizeof(uint16_t)));
30509                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, length_servername_1, sizeof(uint16_t), CH_UTF16));
30510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30511                 }
30512                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30513                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30514                 size_architecture_1 = ndr_get_array_size(ndr, &r->in.architecture);
30515                 length_architecture_1 = ndr_get_array_length(ndr, &r->in.architecture);
30516                 if (length_architecture_1 > size_architecture_1) {
30517                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_architecture_1, length_architecture_1);
30518                 }
30519                 NDR_CHECK(ndr_check_string_terminator(ndr, length_architecture_1, sizeof(uint16_t)));
30520                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, length_architecture_1, sizeof(uint16_t), CH_UTF16));
30521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
30522                 if (_ptr_language) {
30523                         NDR_PULL_ALLOC(ndr, r->in.language);
30524                 } else {
30525                         r->in.language = NULL;
30526                 }
30527                 if (r->in.language) {
30528                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
30529                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
30530                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
30531                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
30532                         size_language_1 = ndr_get_array_size(ndr, &r->in.language);
30533                         length_language_1 = ndr_get_array_length(ndr, &r->in.language);
30534                         if (length_language_1 > size_language_1) {
30535                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_language_1, length_language_1);
30536                         }
30537                         NDR_CHECK(ndr_check_string_terminator(ndr, length_language_1, sizeof(uint16_t)));
30538                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, length_language_1, sizeof(uint16_t), CH_UTF16));
30539                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
30540                 }
30541                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
30542                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
30543                 size_package_id_1 = ndr_get_array_size(ndr, &r->in.package_id);
30544                 length_package_id_1 = ndr_get_array_length(ndr, &r->in.package_id);
30545                 if (length_package_id_1 > size_package_id_1) {
30546                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_package_id_1, length_package_id_1);
30547                 }
30548                 NDR_CHECK(ndr_check_string_terminator(ndr, length_package_id_1, sizeof(uint16_t)));
30549                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.package_id, length_package_id_1, sizeof(uint16_t), CH_UTF16));
30550                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30551                 if (_ptr_driver_package_cab) {
30552                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
30553                 } else {
30554                         r->in.driver_package_cab = NULL;
30555                 }
30556                 if (r->in.driver_package_cab) {
30557                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30558                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
30559                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
30560                         size_driver_package_cab_1 = ndr_get_array_size(ndr, &r->in.driver_package_cab);
30561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver_package_cab, size_driver_package_cab_1, sizeof(uint16_t), CH_UTF16));
30562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30563                 }
30564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
30565                 NDR_PULL_ALLOC(ndr, r->out.required);
30566                 ZERO_STRUCTP(r->out.required);
30567                 if (r->in.driver_package_cab) {
30568                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
30569                 }
30570         }
30571         if (flags & NDR_OUT) {
30572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30573                 if (_ptr_driver_package_cab) {
30574                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
30575                 } else {
30576                         r->out.driver_package_cab = NULL;
30577                 }
30578                 if (r->out.driver_package_cab) {
30579                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30580                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
30581                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
30582                         size_driver_package_cab_1 = ndr_get_array_size(ndr, &r->out.driver_package_cab);
30583                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.driver_package_cab, size_driver_package_cab_1, sizeof(uint16_t), CH_UTF16));
30584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30585                 }
30586                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30587                         NDR_PULL_ALLOC(ndr, r->out.required);
30588                 }
30589                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
30590                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
30591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
30592                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
30593                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30594                 if (r->out.driver_package_cab) {
30595                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
30596                 }
30597         }
30598         return NDR_ERR_SUCCESS;
30599 }
30600
30601 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30602 {
30603         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
30604         ndr->depth++;
30605         if (flags & NDR_SET_VALUES) {
30606                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30607         }
30608         if (flags & NDR_IN) {
30609                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
30610                 ndr->depth++;
30611                 ndr_print_ptr(ndr, "servername", r->in.servername);
30612                 ndr->depth++;
30613                 if (r->in.servername) {
30614                         ndr_print_string(ndr, "servername", r->in.servername);
30615                 }
30616                 ndr->depth--;
30617                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30618                 ndr->depth++;
30619                 ndr_print_string(ndr, "architecture", r->in.architecture);
30620                 ndr->depth--;
30621                 ndr_print_ptr(ndr, "language", r->in.language);
30622                 ndr->depth++;
30623                 if (r->in.language) {
30624                         ndr_print_string(ndr, "language", r->in.language);
30625                 }
30626                 ndr->depth--;
30627                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
30628                 ndr->depth++;
30629                 ndr_print_string(ndr, "package_id", r->in.package_id);
30630                 ndr->depth--;
30631                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
30632                 ndr->depth++;
30633                 if (r->in.driver_package_cab) {
30634                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
30635                 }
30636                 ndr->depth--;
30637                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
30638                 ndr->depth--;
30639         }
30640         if (flags & NDR_OUT) {
30641                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
30642                 ndr->depth++;
30643                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
30644                 ndr->depth++;
30645                 if (r->out.driver_package_cab) {
30646                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
30647                 }
30648                 ndr->depth--;
30649                 ndr_print_ptr(ndr, "required", r->out.required);
30650                 ndr->depth++;
30651                 ndr_print_uint32(ndr, "required", *r->out.required);
30652                 ndr->depth--;
30653                 ndr_print_WERROR(ndr, "result", r->out.result);
30654                 ndr->depth--;
30655         }
30656         ndr->depth--;
30657 }
30658
30659 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
30660 {
30661         if (flags & NDR_IN) {
30662         }
30663         if (flags & NDR_OUT) {
30664                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30665         }
30666         return NDR_ERR_SUCCESS;
30667 }
30668
30669 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
30670 {
30671         if (flags & NDR_IN) {
30672         }
30673         if (flags & NDR_OUT) {
30674                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30675         }
30676         return NDR_ERR_SUCCESS;
30677 }
30678
30679 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
30680 {
30681         ndr_print_struct(ndr, name, "spoolss_69");
30682         ndr->depth++;
30683         if (flags & NDR_SET_VALUES) {
30684                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30685         }
30686         if (flags & NDR_IN) {
30687                 ndr_print_struct(ndr, "in", "spoolss_69");
30688                 ndr->depth++;
30689                 ndr->depth--;
30690         }
30691         if (flags & NDR_OUT) {
30692                 ndr_print_struct(ndr, "out", "spoolss_69");
30693                 ndr->depth++;
30694                 ndr_print_WERROR(ndr, "result", r->out.result);
30695                 ndr->depth--;
30696         }
30697         ndr->depth--;
30698 }
30699
30700 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
30701 {
30702         if (flags & NDR_IN) {
30703         }
30704         if (flags & NDR_OUT) {
30705                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30706         }
30707         return NDR_ERR_SUCCESS;
30708 }
30709
30710 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
30711 {
30712         if (flags & NDR_IN) {
30713         }
30714         if (flags & NDR_OUT) {
30715                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30716         }
30717         return NDR_ERR_SUCCESS;
30718 }
30719
30720 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
30721 {
30722         ndr_print_struct(ndr, name, "spoolss_6a");
30723         ndr->depth++;
30724         if (flags & NDR_SET_VALUES) {
30725                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30726         }
30727         if (flags & NDR_IN) {
30728                 ndr_print_struct(ndr, "in", "spoolss_6a");
30729                 ndr->depth++;
30730                 ndr->depth--;
30731         }
30732         if (flags & NDR_OUT) {
30733                 ndr_print_struct(ndr, "out", "spoolss_6a");
30734                 ndr->depth++;
30735                 ndr_print_WERROR(ndr, "result", r->out.result);
30736                 ndr->depth--;
30737         }
30738         ndr->depth--;
30739 }
30740
30741 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
30742 {
30743         if (flags & NDR_IN) {
30744         }
30745         if (flags & NDR_OUT) {
30746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30747         }
30748         return NDR_ERR_SUCCESS;
30749 }
30750
30751 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
30752 {
30753         if (flags & NDR_IN) {
30754         }
30755         if (flags & NDR_OUT) {
30756                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30757         }
30758         return NDR_ERR_SUCCESS;
30759 }
30760
30761 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30762 {
30763         ndr_print_struct(ndr, name, "spoolss_6b");
30764         ndr->depth++;
30765         if (flags & NDR_SET_VALUES) {
30766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30767         }
30768         if (flags & NDR_IN) {
30769                 ndr_print_struct(ndr, "in", "spoolss_6b");
30770                 ndr->depth++;
30771                 ndr->depth--;
30772         }
30773         if (flags & NDR_OUT) {
30774                 ndr_print_struct(ndr, "out", "spoolss_6b");
30775                 ndr->depth++;
30776                 ndr_print_WERROR(ndr, "result", r->out.result);
30777                 ndr->depth--;
30778         }
30779         ndr->depth--;
30780 }
30781
30782 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30783 {
30784         if (flags & NDR_IN) {
30785         }
30786         if (flags & NDR_OUT) {
30787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30788         }
30789         return NDR_ERR_SUCCESS;
30790 }
30791
30792 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30793 {
30794         if (flags & NDR_IN) {
30795         }
30796         if (flags & NDR_OUT) {
30797                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30798         }
30799         return NDR_ERR_SUCCESS;
30800 }
30801
30802 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30803 {
30804         ndr_print_struct(ndr, name, "spoolss_6c");
30805         ndr->depth++;
30806         if (flags & NDR_SET_VALUES) {
30807                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30808         }
30809         if (flags & NDR_IN) {
30810                 ndr_print_struct(ndr, "in", "spoolss_6c");
30811                 ndr->depth++;
30812                 ndr->depth--;
30813         }
30814         if (flags & NDR_OUT) {
30815                 ndr_print_struct(ndr, "out", "spoolss_6c");
30816                 ndr->depth++;
30817                 ndr_print_WERROR(ndr, "result", r->out.result);
30818                 ndr->depth--;
30819         }
30820         ndr->depth--;
30821 }
30822
30823 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30824 {
30825         if (flags & NDR_IN) {
30826         }
30827         if (flags & NDR_OUT) {
30828                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30829         }
30830         return NDR_ERR_SUCCESS;
30831 }
30832
30833 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30834 {
30835         if (flags & NDR_IN) {
30836         }
30837         if (flags & NDR_OUT) {
30838                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30839         }
30840         return NDR_ERR_SUCCESS;
30841 }
30842
30843 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30844 {
30845         ndr_print_struct(ndr, name, "spoolss_6d");
30846         ndr->depth++;
30847         if (flags & NDR_SET_VALUES) {
30848                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30849         }
30850         if (flags & NDR_IN) {
30851                 ndr_print_struct(ndr, "in", "spoolss_6d");
30852                 ndr->depth++;
30853                 ndr->depth--;
30854         }
30855         if (flags & NDR_OUT) {
30856                 ndr_print_struct(ndr, "out", "spoolss_6d");
30857                 ndr->depth++;
30858                 ndr_print_WERROR(ndr, "result", r->out.result);
30859                 ndr->depth--;
30860         }
30861         ndr->depth--;
30862 }
30863
30864 static const struct ndr_interface_call spoolss_calls[] = {
30865         {
30866                 "spoolss_EnumPrinters",
30867                 sizeof(struct spoolss_EnumPrinters),
30868                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30870                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30871                 false,
30872         },
30873         {
30874                 "spoolss_OpenPrinter",
30875                 sizeof(struct spoolss_OpenPrinter),
30876                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30878                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30879                 false,
30880         },
30881         {
30882                 "spoolss_SetJob",
30883                 sizeof(struct spoolss_SetJob),
30884                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30886                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30887                 false,
30888         },
30889         {
30890                 "spoolss_GetJob",
30891                 sizeof(struct spoolss_GetJob),
30892                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30894                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30895                 false,
30896         },
30897         {
30898                 "spoolss_EnumJobs",
30899                 sizeof(struct spoolss_EnumJobs),
30900                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30902                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30903                 false,
30904         },
30905         {
30906                 "spoolss_AddPrinter",
30907                 sizeof(struct spoolss_AddPrinter),
30908                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30910                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30911                 false,
30912         },
30913         {
30914                 "spoolss_DeletePrinter",
30915                 sizeof(struct spoolss_DeletePrinter),
30916                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30918                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30919                 false,
30920         },
30921         {
30922                 "spoolss_SetPrinter",
30923                 sizeof(struct spoolss_SetPrinter),
30924                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30926                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30927                 false,
30928         },
30929         {
30930                 "spoolss_GetPrinter",
30931                 sizeof(struct spoolss_GetPrinter),
30932                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30934                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30935                 false,
30936         },
30937         {
30938                 "spoolss_AddPrinterDriver",
30939                 sizeof(struct spoolss_AddPrinterDriver),
30940                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30942                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30943                 false,
30944         },
30945         {
30946                 "spoolss_EnumPrinterDrivers",
30947                 sizeof(struct spoolss_EnumPrinterDrivers),
30948                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30950                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30951                 false,
30952         },
30953         {
30954                 "spoolss_GetPrinterDriver",
30955                 sizeof(struct spoolss_GetPrinterDriver),
30956                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30958                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30959                 false,
30960         },
30961         {
30962                 "spoolss_GetPrinterDriverDirectory",
30963                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30964                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30966                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30967                 false,
30968         },
30969         {
30970                 "spoolss_DeletePrinterDriver",
30971                 sizeof(struct spoolss_DeletePrinterDriver),
30972                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30974                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30975                 false,
30976         },
30977         {
30978                 "spoolss_AddPrintProcessor",
30979                 sizeof(struct spoolss_AddPrintProcessor),
30980                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30982                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30983                 false,
30984         },
30985         {
30986                 "spoolss_EnumPrintProcessors",
30987                 sizeof(struct spoolss_EnumPrintProcessors),
30988                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30990                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30991                 false,
30992         },
30993         {
30994                 "spoolss_GetPrintProcessorDirectory",
30995                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30996                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30998                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30999                 false,
31000         },
31001         {
31002                 "spoolss_StartDocPrinter",
31003                 sizeof(struct spoolss_StartDocPrinter),
31004                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
31005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
31006                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
31007                 false,
31008         },
31009         {
31010                 "spoolss_StartPagePrinter",
31011                 sizeof(struct spoolss_StartPagePrinter),
31012                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
31013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
31014                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
31015                 false,
31016         },
31017         {
31018                 "spoolss_WritePrinter",
31019                 sizeof(struct spoolss_WritePrinter),
31020                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
31021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
31022                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
31023                 false,
31024         },
31025         {
31026                 "spoolss_EndPagePrinter",
31027                 sizeof(struct spoolss_EndPagePrinter),
31028                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
31029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
31030                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
31031                 false,
31032         },
31033         {
31034                 "spoolss_AbortPrinter",
31035                 sizeof(struct spoolss_AbortPrinter),
31036                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
31037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
31038                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
31039                 false,
31040         },
31041         {
31042                 "spoolss_ReadPrinter",
31043                 sizeof(struct spoolss_ReadPrinter),
31044                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
31045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
31046                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
31047                 false,
31048         },
31049         {
31050                 "spoolss_EndDocPrinter",
31051                 sizeof(struct spoolss_EndDocPrinter),
31052                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
31053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
31054                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
31055                 false,
31056         },
31057         {
31058                 "spoolss_AddJob",
31059                 sizeof(struct spoolss_AddJob),
31060                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
31061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
31062                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
31063                 false,
31064         },
31065         {
31066                 "spoolss_ScheduleJob",
31067                 sizeof(struct spoolss_ScheduleJob),
31068                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
31069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
31070                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
31071                 false,
31072         },
31073         {
31074                 "spoolss_GetPrinterData",
31075                 sizeof(struct spoolss_GetPrinterData),
31076                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
31077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
31078                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
31079                 false,
31080         },
31081         {
31082                 "spoolss_SetPrinterData",
31083                 sizeof(struct spoolss_SetPrinterData),
31084                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
31085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
31086                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
31087                 false,
31088         },
31089         {
31090                 "spoolss_WaitForPrinterChange",
31091                 sizeof(struct spoolss_WaitForPrinterChange),
31092                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
31093                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
31094                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
31095                 false,
31096         },
31097         {
31098                 "spoolss_ClosePrinter",
31099                 sizeof(struct spoolss_ClosePrinter),
31100                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
31101                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
31102                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
31103                 false,
31104         },
31105         {
31106                 "spoolss_AddForm",
31107                 sizeof(struct spoolss_AddForm),
31108                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
31109                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
31110                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
31111                 false,
31112         },
31113         {
31114                 "spoolss_DeleteForm",
31115                 sizeof(struct spoolss_DeleteForm),
31116                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
31117                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
31118                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
31119                 false,
31120         },
31121         {
31122                 "spoolss_GetForm",
31123                 sizeof(struct spoolss_GetForm),
31124                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
31125                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
31126                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
31127                 false,
31128         },
31129         {
31130                 "spoolss_SetForm",
31131                 sizeof(struct spoolss_SetForm),
31132                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
31133                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
31134                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
31135                 false,
31136         },
31137         {
31138                 "spoolss_EnumForms",
31139                 sizeof(struct spoolss_EnumForms),
31140                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
31141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
31142                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
31143                 false,
31144         },
31145         {
31146                 "spoolss_EnumPorts",
31147                 sizeof(struct spoolss_EnumPorts),
31148                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
31149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
31150                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
31151                 false,
31152         },
31153         {
31154                 "spoolss_EnumMonitors",
31155                 sizeof(struct spoolss_EnumMonitors),
31156                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
31157                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
31158                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
31159                 false,
31160         },
31161         {
31162                 "spoolss_AddPort",
31163                 sizeof(struct spoolss_AddPort),
31164                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
31165                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
31166                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
31167                 false,
31168         },
31169         {
31170                 "spoolss_ConfigurePort",
31171                 sizeof(struct spoolss_ConfigurePort),
31172                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
31173                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
31174                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
31175                 false,
31176         },
31177         {
31178                 "spoolss_DeletePort",
31179                 sizeof(struct spoolss_DeletePort),
31180                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
31181                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
31182                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
31183                 false,
31184         },
31185         {
31186                 "spoolss_CreatePrinterIC",
31187                 sizeof(struct spoolss_CreatePrinterIC),
31188                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
31189                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
31190                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
31191                 false,
31192         },
31193         {
31194                 "spoolss_PlayGDIScriptOnPrinterIC",
31195                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
31196                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
31197                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
31198                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
31199                 false,
31200         },
31201         {
31202                 "spoolss_DeletePrinterIC",
31203                 sizeof(struct spoolss_DeletePrinterIC),
31204                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
31205                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
31206                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
31207                 false,
31208         },
31209         {
31210                 "spoolss_AddPrinterConnection",
31211                 sizeof(struct spoolss_AddPrinterConnection),
31212                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
31213                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
31214                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
31215                 false,
31216         },
31217         {
31218                 "spoolss_DeletePrinterConnection",
31219                 sizeof(struct spoolss_DeletePrinterConnection),
31220                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
31221                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
31222                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
31223                 false,
31224         },
31225         {
31226                 "spoolss_PrinterMessageBox",
31227                 sizeof(struct spoolss_PrinterMessageBox),
31228                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
31229                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
31230                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
31231                 false,
31232         },
31233         {
31234                 "spoolss_AddMonitor",
31235                 sizeof(struct spoolss_AddMonitor),
31236                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
31237                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
31238                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
31239                 false,
31240         },
31241         {
31242                 "spoolss_DeleteMonitor",
31243                 sizeof(struct spoolss_DeleteMonitor),
31244                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
31245                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
31246                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
31247                 false,
31248         },
31249         {
31250                 "spoolss_DeletePrintProcessor",
31251                 sizeof(struct spoolss_DeletePrintProcessor),
31252                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
31253                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
31254                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
31255                 false,
31256         },
31257         {
31258                 "spoolss_AddPrintProvidor",
31259                 sizeof(struct spoolss_AddPrintProvidor),
31260                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
31261                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
31262                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
31263                 false,
31264         },
31265         {
31266                 "spoolss_DeletePrintProvidor",
31267                 sizeof(struct spoolss_DeletePrintProvidor),
31268                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
31269                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
31270                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
31271                 false,
31272         },
31273         {
31274                 "spoolss_EnumPrintProcDataTypes",
31275                 sizeof(struct spoolss_EnumPrintProcDataTypes),
31276                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
31277                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
31278                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
31279                 false,
31280         },
31281         {
31282                 "spoolss_ResetPrinter",
31283                 sizeof(struct spoolss_ResetPrinter),
31284                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
31285                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
31286                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
31287                 false,
31288         },
31289         {
31290                 "spoolss_GetPrinterDriver2",
31291                 sizeof(struct spoolss_GetPrinterDriver2),
31292                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
31293                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
31294                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
31295                 false,
31296         },
31297         {
31298                 "spoolss_FindFirstPrinterChangeNotification",
31299                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
31300                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
31301                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
31302                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
31303                 false,
31304         },
31305         {
31306                 "spoolss_FindNextPrinterChangeNotification",
31307                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
31308                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
31309                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
31310                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
31311                 false,
31312         },
31313         {
31314                 "spoolss_FindClosePrinterNotify",
31315                 sizeof(struct spoolss_FindClosePrinterNotify),
31316                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
31317                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
31318                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
31319                 false,
31320         },
31321         {
31322                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
31323                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
31324                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31326                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31327                 false,
31328         },
31329         {
31330                 "spoolss_ReplyOpenPrinter",
31331                 sizeof(struct spoolss_ReplyOpenPrinter),
31332                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
31333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
31334                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
31335                 false,
31336         },
31337         {
31338                 "spoolss_RouterReplyPrinter",
31339                 sizeof(struct spoolss_RouterReplyPrinter),
31340                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
31341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
31342                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
31343                 false,
31344         },
31345         {
31346                 "spoolss_ReplyClosePrinter",
31347                 sizeof(struct spoolss_ReplyClosePrinter),
31348                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
31349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
31350                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
31351                 false,
31352         },
31353         {
31354                 "spoolss_AddPortEx",
31355                 sizeof(struct spoolss_AddPortEx),
31356                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
31357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
31358                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
31359                 false,
31360         },
31361         {
31362                 "spoolss_RouterFindFirstPrinterChangeNotification",
31363                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
31364                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
31365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
31366                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
31367                 false,
31368         },
31369         {
31370                 "spoolss_SpoolerInit",
31371                 sizeof(struct spoolss_SpoolerInit),
31372                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
31373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
31374                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
31375                 false,
31376         },
31377         {
31378                 "spoolss_ResetPrinterEx",
31379                 sizeof(struct spoolss_ResetPrinterEx),
31380                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
31381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
31382                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
31383                 false,
31384         },
31385         {
31386                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
31387                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
31388                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31390                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31391                 false,
31392         },
31393         {
31394                 "spoolss_RouterReplyPrinterEx",
31395                 sizeof(struct spoolss_RouterReplyPrinterEx),
31396                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
31397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
31398                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
31399                 false,
31400         },
31401         {
31402                 "spoolss_RouterRefreshPrinterChangeNotify",
31403                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
31404                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
31405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
31406                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
31407                 false,
31408         },
31409         {
31410                 "spoolss_44",
31411                 sizeof(struct spoolss_44),
31412                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
31413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
31414                 (ndr_print_function_t) ndr_print_spoolss_44,
31415                 false,
31416         },
31417         {
31418                 "spoolss_OpenPrinterEx",
31419                 sizeof(struct spoolss_OpenPrinterEx),
31420                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
31421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
31422                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
31423                 false,
31424         },
31425         {
31426                 "spoolss_AddPrinterEx",
31427                 sizeof(struct spoolss_AddPrinterEx),
31428                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
31429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
31430                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
31431                 false,
31432         },
31433         {
31434                 "spoolss_47",
31435                 sizeof(struct spoolss_47),
31436                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
31437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
31438                 (ndr_print_function_t) ndr_print_spoolss_47,
31439                 false,
31440         },
31441         {
31442                 "spoolss_EnumPrinterData",
31443                 sizeof(struct spoolss_EnumPrinterData),
31444                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
31445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
31446                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
31447                 false,
31448         },
31449         {
31450                 "spoolss_DeletePrinterData",
31451                 sizeof(struct spoolss_DeletePrinterData),
31452                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
31453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
31454                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
31455                 false,
31456         },
31457         {
31458                 "spoolss_4a",
31459                 sizeof(struct spoolss_4a),
31460                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
31461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
31462                 (ndr_print_function_t) ndr_print_spoolss_4a,
31463                 false,
31464         },
31465         {
31466                 "spoolss_4b",
31467                 sizeof(struct spoolss_4b),
31468                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
31469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
31470                 (ndr_print_function_t) ndr_print_spoolss_4b,
31471                 false,
31472         },
31473         {
31474                 "spoolss_4c",
31475                 sizeof(struct spoolss_4c),
31476                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
31477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
31478                 (ndr_print_function_t) ndr_print_spoolss_4c,
31479                 false,
31480         },
31481         {
31482                 "spoolss_SetPrinterDataEx",
31483                 sizeof(struct spoolss_SetPrinterDataEx),
31484                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
31485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
31486                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
31487                 false,
31488         },
31489         {
31490                 "spoolss_GetPrinterDataEx",
31491                 sizeof(struct spoolss_GetPrinterDataEx),
31492                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
31493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
31494                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
31495                 false,
31496         },
31497         {
31498                 "spoolss_EnumPrinterDataEx",
31499                 sizeof(struct spoolss_EnumPrinterDataEx),
31500                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
31501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
31502                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
31503                 false,
31504         },
31505         {
31506                 "spoolss_EnumPrinterKey",
31507                 sizeof(struct spoolss_EnumPrinterKey),
31508                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
31509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
31510                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
31511                 false,
31512         },
31513         {
31514                 "spoolss_DeletePrinterDataEx",
31515                 sizeof(struct spoolss_DeletePrinterDataEx),
31516                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
31517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
31518                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
31519                 false,
31520         },
31521         {
31522                 "spoolss_DeletePrinterKey",
31523                 sizeof(struct spoolss_DeletePrinterKey),
31524                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
31525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
31526                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
31527                 false,
31528         },
31529         {
31530                 "spoolss_53",
31531                 sizeof(struct spoolss_53),
31532                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
31533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
31534                 (ndr_print_function_t) ndr_print_spoolss_53,
31535                 false,
31536         },
31537         {
31538                 "spoolss_DeletePrinterDriverEx",
31539                 sizeof(struct spoolss_DeletePrinterDriverEx),
31540                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
31541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
31542                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
31543                 false,
31544         },
31545         {
31546                 "spoolss_55",
31547                 sizeof(struct spoolss_55),
31548                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
31549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
31550                 (ndr_print_function_t) ndr_print_spoolss_55,
31551                 false,
31552         },
31553         {
31554                 "spoolss_56",
31555                 sizeof(struct spoolss_56),
31556                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
31557                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
31558                 (ndr_print_function_t) ndr_print_spoolss_56,
31559                 false,
31560         },
31561         {
31562                 "spoolss_57",
31563                 sizeof(struct spoolss_57),
31564                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
31565                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
31566                 (ndr_print_function_t) ndr_print_spoolss_57,
31567                 false,
31568         },
31569         {
31570                 "spoolss_XcvData",
31571                 sizeof(struct spoolss_XcvData),
31572                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
31573                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
31574                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
31575                 false,
31576         },
31577         {
31578                 "spoolss_AddPrinterDriverEx",
31579                 sizeof(struct spoolss_AddPrinterDriverEx),
31580                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
31581                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
31582                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
31583                 false,
31584         },
31585         {
31586                 "spoolss_5a",
31587                 sizeof(struct spoolss_5a),
31588                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
31589                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
31590                 (ndr_print_function_t) ndr_print_spoolss_5a,
31591                 false,
31592         },
31593         {
31594                 "spoolss_5b",
31595                 sizeof(struct spoolss_5b),
31596                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
31597                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
31598                 (ndr_print_function_t) ndr_print_spoolss_5b,
31599                 false,
31600         },
31601         {
31602                 "spoolss_5c",
31603                 sizeof(struct spoolss_5c),
31604                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
31605                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
31606                 (ndr_print_function_t) ndr_print_spoolss_5c,
31607                 false,
31608         },
31609         {
31610                 "spoolss_5d",
31611                 sizeof(struct spoolss_5d),
31612                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
31613                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
31614                 (ndr_print_function_t) ndr_print_spoolss_5d,
31615                 false,
31616         },
31617         {
31618                 "spoolss_5e",
31619                 sizeof(struct spoolss_5e),
31620                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
31621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
31622                 (ndr_print_function_t) ndr_print_spoolss_5e,
31623                 false,
31624         },
31625         {
31626                 "spoolss_5f",
31627                 sizeof(struct spoolss_5f),
31628                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
31629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
31630                 (ndr_print_function_t) ndr_print_spoolss_5f,
31631                 false,
31632         },
31633         {
31634                 "spoolss_60",
31635                 sizeof(struct spoolss_60),
31636                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
31637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
31638                 (ndr_print_function_t) ndr_print_spoolss_60,
31639                 false,
31640         },
31641         {
31642                 "spoolss_61",
31643                 sizeof(struct spoolss_61),
31644                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
31645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
31646                 (ndr_print_function_t) ndr_print_spoolss_61,
31647                 false,
31648         },
31649         {
31650                 "spoolss_62",
31651                 sizeof(struct spoolss_62),
31652                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
31653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
31654                 (ndr_print_function_t) ndr_print_spoolss_62,
31655                 false,
31656         },
31657         {
31658                 "spoolss_63",
31659                 sizeof(struct spoolss_63),
31660                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
31661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
31662                 (ndr_print_function_t) ndr_print_spoolss_63,
31663                 false,
31664         },
31665         {
31666                 "spoolss_64",
31667                 sizeof(struct spoolss_64),
31668                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
31669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
31670                 (ndr_print_function_t) ndr_print_spoolss_64,
31671                 false,
31672         },
31673         {
31674                 "spoolss_65",
31675                 sizeof(struct spoolss_65),
31676                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
31677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
31678                 (ndr_print_function_t) ndr_print_spoolss_65,
31679                 false,
31680         },
31681         {
31682                 "spoolss_GetCorePrinterDrivers",
31683                 sizeof(struct spoolss_GetCorePrinterDrivers),
31684                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
31685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
31686                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
31687                 false,
31688         },
31689         {
31690                 "spoolss_67",
31691                 sizeof(struct spoolss_67),
31692                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
31693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
31694                 (ndr_print_function_t) ndr_print_spoolss_67,
31695                 false,
31696         },
31697         {
31698                 "spoolss_GetPrinterDriverPackagePath",
31699                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
31700                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
31701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
31702                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
31703                 false,
31704         },
31705         {
31706                 "spoolss_69",
31707                 sizeof(struct spoolss_69),
31708                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
31709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
31710                 (ndr_print_function_t) ndr_print_spoolss_69,
31711                 false,
31712         },
31713         {
31714                 "spoolss_6a",
31715                 sizeof(struct spoolss_6a),
31716                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
31717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
31718                 (ndr_print_function_t) ndr_print_spoolss_6a,
31719                 false,
31720         },
31721         {
31722                 "spoolss_6b",
31723                 sizeof(struct spoolss_6b),
31724                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
31725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
31726                 (ndr_print_function_t) ndr_print_spoolss_6b,
31727                 false,
31728         },
31729         {
31730                 "spoolss_6c",
31731                 sizeof(struct spoolss_6c),
31732                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
31733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
31734                 (ndr_print_function_t) ndr_print_spoolss_6c,
31735                 false,
31736         },
31737         {
31738                 "spoolss_6d",
31739                 sizeof(struct spoolss_6d),
31740                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
31741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
31742                 (ndr_print_function_t) ndr_print_spoolss_6d,
31743                 false,
31744         },
31745         { NULL, 0, NULL, NULL, NULL, false }
31746 };
31747
31748 static const char * const spoolss_endpoint_strings[] = {
31749         "ncacn_np:[\\pipe\\spoolss]",
31750 };
31751
31752 static const struct ndr_interface_string_array spoolss_endpoints = {
31753         .count  = 1,
31754         .names  = spoolss_endpoint_strings
31755 };
31756
31757 static const char * const spoolss_authservice_strings[] = {
31758         "host",
31759 };
31760
31761 static const struct ndr_interface_string_array spoolss_authservices = {
31762         .count  = 1,
31763         .names  = spoolss_authservice_strings
31764 };
31765
31766
31767 const struct ndr_interface_table ndr_table_spoolss = {
31768         .name           = "spoolss",
31769         .syntax_id      = {
31770                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31771                 NDR_SPOOLSS_VERSION
31772         },
31773         .helpstring     = NDR_SPOOLSS_HELPSTRING,
31774         .num_calls      = 110,
31775         .calls          = spoolss_calls,
31776         .endpoints      = &spoolss_endpoints,
31777         .authservices   = &spoolss_authservices
31778 };
31779