librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 228 {
 229         if (ndr_flags & NDR_SCALARS) {
 230                 NDR_CHECK(ndr_push_align(ndr, 4));
 231                 {
 232                         uint32_t _flags_save_string = ndr->flags;
 233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 235                         ndr->flags = _flags_save_string;
 236                 }
 237                 {
 238                         uint32_t _flags_save_string = ndr->flags;
 239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 241                         ndr->flags = _flags_save_string;
 242                 }
 243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 246                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
 257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 258                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
 263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 265                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 266                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 270         }
 271         if (ndr_flags & NDR_BUFFERS) {
 272                 {
 273                         uint32_t _flags_save_string = ndr->flags;
 274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 275                         if (r->printername) {
 276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 278                         }
 279                         ndr->flags = _flags_save_string;
 280                 }
 281                 {
 282                         uint32_t _flags_save_string = ndr->flags;
 283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 284                         if (r->servername) {
 285                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 286                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 287                         }
 288                         ndr->flags = _flags_save_string;
 289                 }
 290         }
 291         return NDR_ERR_SUCCESS;
 292 }
 293
 294 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 295 {
 296         uint32_t _ptr_printername;
 297         TALLOC_CTX *_mem_save_printername_0;
 298         uint32_t _ptr_servername;
 299         TALLOC_CTX *_mem_save_servername_0;
 300         if (ndr_flags & NDR_SCALARS) {
 301                 NDR_CHECK(ndr_pull_align(ndr, 4));
 302                 {
 303                         uint32_t _flags_save_string = ndr->flags;
 304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 306                         if (_ptr_printername) {
 307                                 NDR_PULL_ALLOC(ndr, r->printername);
 308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 309                         } else {
 310                                 r->printername = NULL;
 311                         }
 312                         ndr->flags = _flags_save_string;
 313                 }
 314                 {
 315                         uint32_t _flags_save_string = ndr->flags;
 316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 318                         if (_ptr_servername) {
 319                                 NDR_PULL_ALLOC(ndr, r->servername);
 320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 321                         } else {
 322                                 r->servername = NULL;
 323                         }
 324                         ndr->flags = _flags_save_string;
 325                 }
 326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 329                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
 340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 341                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 348                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 349                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 353         }
 354         if (ndr_flags & NDR_BUFFERS) {
 355                 {
 356                         uint32_t _flags_save_string = ndr->flags;
 357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 358                         if (r->printername) {
 359                                 uint32_t _relative_save_offset;
 360                                 _relative_save_offset = ndr->offset;
 361                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 362                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 363                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 364                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 365                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 366                                 ndr->offset = _relative_save_offset;
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370                 {
 371                         uint32_t _flags_save_string = ndr->flags;
 372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 373                         if (r->servername) {
 374                                 uint32_t _relative_save_offset;
 375                                 _relative_save_offset = ndr->offset;
 376                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 377                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 378                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 379                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 381                                 ndr->offset = _relative_save_offset;
 382                         }
 383                         ndr->flags = _flags_save_string;
 384                 }
 385         }
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 390 {
 391         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 392         ndr->depth++;
 393         ndr_print_ptr(ndr, "printername", r->printername);
 394         ndr->depth++;
 395         if (r->printername) {
 396                 ndr_print_string(ndr, "printername", r->printername);
 397         }
 398         ndr->depth--;
 399         ndr_print_ptr(ndr, "servername", r->servername);
 400         ndr->depth++;
 401         if (r->servername) {
 402                 ndr_print_string(ndr, "servername", r->servername);
 403         }
 404         ndr->depth--;
 405         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 406         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 407         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 408         ndr_print_spoolss_Time(ndr, "time", &r->time);
 409         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 410         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 411         ndr_print_uint32(ndr, "version", r->version);
 412         ndr_print_uint32(ndr, "free_build", r->free_build);
 413         ndr_print_uint32(ndr, "spooling", r->spooling);
 414         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 415         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 416         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 417         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 418         ndr_print_uint32(ndr, "job_error", r->job_error);
 419         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 420         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 421         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 422         ndr_print_uint32(ndr, "change_id", r->change_id);
 423         ndr_print_WERROR(ndr, "last_error", r->last_error);
 424         ndr_print_uint32(ndr, "status", r->status);
 425         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 426         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 427         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 428         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 429         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 430         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 431         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 432         ndr->depth--;
 433 }
 434
 435 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 436 {
 437         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 438         return NDR_ERR_SUCCESS;
 439 }
 440
 441 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 442 {
 443         uint32_t v;
 444         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 445         *r = v;
 446         return NDR_ERR_SUCCESS;
 447 }
 448
 449 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 450 {
 451         ndr_print_uint32(ndr, name, r);
 452         ndr->depth++;
 453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 463         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 464         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 465         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 466         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 467         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 468         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 469         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 470         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 471         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 472         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 473         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 474         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 475         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 476         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 478         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 480         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 481         ndr->depth--;
 482 }
 483
 484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 485 {
 486         if (ndr_flags & NDR_SCALARS) {
 487                 NDR_CHECK(ndr_push_align(ndr, 4));
 488                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 489                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 490                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 491                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 492                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 493                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 494                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 496                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 497                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 498                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 499                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 500                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 501                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 502                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 503                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 504                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 505                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 506                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 507                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 508                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 522                 {
 523                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 525                         {
 526                                 struct ndr_push *_ndr_driverextra_data;
 527                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 528                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 529                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 530                         }
 531                         ndr->flags = _flags_save_DATA_BLOB;
 532                 }
 533         }
 534         if (ndr_flags & NDR_BUFFERS) {
 535         }
 536         return NDR_ERR_SUCCESS;
 537 }
 538
 539 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 540 {
 541         if (ndr_flags & NDR_SCALARS) {
 542                 NDR_CHECK(ndr_pull_align(ndr, 4));
 543                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 544                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 545                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 546                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 547                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 548                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 549                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 550                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 551                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 552                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 553                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 554                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 555                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 556                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 557                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 558                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 559                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 560                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 562                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 563                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 577                 {
 578                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 580                         {
 581                                 struct ndr_pull *_ndr_driverextra_data;
 582                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 583                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 584                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 585                         }
 586                         ndr->flags = _flags_save_DATA_BLOB;
 587                 }
 588         }
 589         if (ndr_flags & NDR_BUFFERS) {
 590         }
 591         return NDR_ERR_SUCCESS;
 592 }
 593
 594 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 595 {
 596         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 597         ndr->depth++;
 598         ndr_print_string(ndr, "devicename", r->devicename);
 599         ndr_print_uint16(ndr, "specversion", r->specversion);
 600         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 601         ndr_print_uint16(ndr, "size", r->size);
 602         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 603         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 604         ndr_print_uint16(ndr, "orientation", r->orientation);
 605         ndr_print_uint16(ndr, "papersize", r->papersize);
 606         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 607         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 608         ndr_print_uint16(ndr, "scale", r->scale);
 609         ndr_print_uint16(ndr, "copies", r->copies);
 610         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 611         ndr_print_uint16(ndr, "printquality", r->printquality);
 612         ndr_print_uint16(ndr, "color", r->color);
 613         ndr_print_uint16(ndr, "duplex", r->duplex);
 614         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 615         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 616         ndr_print_uint16(ndr, "collate", r->collate);
 617         ndr_print_string(ndr, "formname", r->formname);
 618         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 619         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 620         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 621         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 622         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 623         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 624         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 625         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 626         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 627         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 628         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 629         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 630         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 631         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 632         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 633         ndr->depth--;
 634 }
 635
 636 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 637 {
 638         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 639 }
 640
 641 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 642 {
 643         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 644         return NDR_ERR_SUCCESS;
 645 }
 646
 647 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 648 {
 649         uint32_t v;
 650         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 651         *r = v;
 652         return NDR_ERR_SUCCESS;
 653 }
 654
 655 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 656 {
 657         ndr_print_uint32(ndr, name, r);
 658         ndr->depth++;
 659         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 660         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 661         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 662         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 664         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 665         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 666         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 668         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 677         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 678         ndr->depth--;
 679 }
 680
 681 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 682 {
 683         if (ndr_flags & NDR_SCALARS) {
 684                 NDR_CHECK(ndr_push_align(ndr, 4));
 685                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 686                 {
 687                         uint32_t _flags_save_string = ndr->flags;
 688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 689                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 690                         ndr->flags = _flags_save_string;
 691                 }
 692                 {
 693                         uint32_t _flags_save_string = ndr->flags;
 694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 695                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 696                         ndr->flags = _flags_save_string;
 697                 }
 698                 {
 699                         uint32_t _flags_save_string = ndr->flags;
 700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 701                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 702                         ndr->flags = _flags_save_string;
 703                 }
 704         }
 705         if (ndr_flags & NDR_BUFFERS) {
 706                 {
 707                         uint32_t _flags_save_string = ndr->flags;
 708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 709                         if (r->name) {
 710                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 711                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 712                         }
 713                         ndr->flags = _flags_save_string;
 714                 }
 715                 {
 716                         uint32_t _flags_save_string = ndr->flags;
 717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 718                         if (r->description) {
 719                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 720                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 721                         }
 722                         ndr->flags = _flags_save_string;
 723                 }
 724                 {
 725                         uint32_t _flags_save_string = ndr->flags;
 726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 727                         if (r->comment) {
 728                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 730                         }
 731                         ndr->flags = _flags_save_string;
 732                 }
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 738 {
 739         uint32_t _ptr_name;
 740         TALLOC_CTX *_mem_save_name_0;
 741         uint32_t _ptr_description;
 742         TALLOC_CTX *_mem_save_description_0;
 743         uint32_t _ptr_comment;
 744         TALLOC_CTX *_mem_save_comment_0;
 745         if (ndr_flags & NDR_SCALARS) {
 746                 NDR_CHECK(ndr_pull_align(ndr, 4));
 747                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 748                 {
 749                         uint32_t _flags_save_string = ndr->flags;
 750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 752                         if (_ptr_name) {
 753                                 NDR_PULL_ALLOC(ndr, r->name);
 754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 755                         } else {
 756                                 r->name = NULL;
 757                         }
 758                         ndr->flags = _flags_save_string;
 759                 }
 760                 {
 761                         uint32_t _flags_save_string = ndr->flags;
 762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 764                         if (_ptr_description) {
 765                                 NDR_PULL_ALLOC(ndr, r->description);
 766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 767                         } else {
 768                                 r->description = NULL;
 769                         }
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 776                         if (_ptr_comment) {
 777                                 NDR_PULL_ALLOC(ndr, r->comment);
 778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 779                         } else {
 780                                 r->comment = NULL;
 781                         }
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 uint32_t _relative_save_offset;
 791                                 _relative_save_offset = ndr->offset;
 792                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 793                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 794                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 795                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 796                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 797                                 ndr->offset = _relative_save_offset;
 798                         }
 799                         ndr->flags = _flags_save_string;
 800                 }
 801                 {
 802                         uint32_t _flags_save_string = ndr->flags;
 803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 804                         if (r->description) {
 805                                 uint32_t _relative_save_offset;
 806                                 _relative_save_offset = ndr->offset;
 807                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 808                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 809                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 810                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 811                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 812                                 ndr->offset = _relative_save_offset;
 813                         }
 814                         ndr->flags = _flags_save_string;
 815                 }
 816                 {
 817                         uint32_t _flags_save_string = ndr->flags;
 818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 819                         if (r->comment) {
 820                                 uint32_t _relative_save_offset;
 821                                 _relative_save_offset = ndr->offset;
 822                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 823                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 824                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 825                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 826                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 827                                 ndr->offset = _relative_save_offset;
 828                         }
 829                         ndr->flags = _flags_save_string;
 830                 }
 831         }
 832         return NDR_ERR_SUCCESS;
 833 }
 834
 835 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 836 {
 837         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 838         ndr->depth++;
 839         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 840         ndr_print_ptr(ndr, "name", r->name);
 841         ndr->depth++;
 842         if (r->name) {
 843                 ndr_print_string(ndr, "name", r->name);
 844         }
 845         ndr->depth--;
 846         ndr_print_ptr(ndr, "description", r->description);
 847         ndr->depth++;
 848         if (r->description) {
 849                 ndr_print_string(ndr, "description", r->description);
 850         }
 851         ndr->depth--;
 852         ndr_print_ptr(ndr, "comment", r->comment);
 853         ndr->depth++;
 854         if (r->comment) {
 855                 ndr_print_string(ndr, "comment", r->comment);
 856         }
 857         ndr->depth--;
 858         ndr->depth--;
 859 }
 860
 861 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 862 {
 863         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 868 {
 869         uint32_t v;
 870         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 871         *r = v;
 872         return NDR_ERR_SUCCESS;
 873 }
 874
 875 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 876 {
 877         ndr_print_uint32(ndr, name, r);
 878         ndr->depth++;
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 889         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 890         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 891         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 892         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 893         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 894         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 895         ndr->depth--;
 896 }
 897
 898 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 899 {
 900         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 901         return NDR_ERR_SUCCESS;
 902 }
 903
 904 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 905 {
 906         uint32_t v;
 907         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 908         *r = v;
 909         return NDR_ERR_SUCCESS;
 910 }
 911
 912 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 913 {
 914         ndr_print_uint32(ndr, name, r);
 915         ndr->depth++;
 916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 918         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 928         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 933         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 934         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 935         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 936         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 937         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 938         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 941         ndr->depth--;
 942 }
 943
 944 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 945 {
 946         if (ndr_flags & NDR_SCALARS) {
 947                 NDR_CHECK(ndr_push_align(ndr, 4));
 948                 {
 949                         uint32_t _flags_save_string = ndr->flags;
 950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 951                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 952                         ndr->flags = _flags_save_string;
 953                 }
 954                 {
 955                         uint32_t _flags_save_string = ndr->flags;
 956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 957                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 958                         ndr->flags = _flags_save_string;
 959                 }
 960                 {
 961                         uint32_t _flags_save_string = ndr->flags;
 962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 964                         ndr->flags = _flags_save_string;
 965                 }
 966                 {
 967                         uint32_t _flags_save_string = ndr->flags;
 968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
 970                         ndr->flags = _flags_save_string;
 971                 }
 972                 {
 973                         uint32_t _flags_save_string = ndr->flags;
 974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
 976                         ndr->flags = _flags_save_string;
 977                 }
 978                 {
 979                         uint32_t _flags_save_string = ndr->flags;
 980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 982                         ndr->flags = _flags_save_string;
 983                 }
 984                 {
 985                         uint32_t _flags_save_string = ndr->flags;
 986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
 988                         ndr->flags = _flags_save_string;
 989                 }
 990                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
 991                 {
 992                         uint32_t _flags_save_string = ndr->flags;
 993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 994                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
 995                         ndr->flags = _flags_save_string;
 996                 }
 997                 {
 998                         uint32_t _flags_save_string = ndr->flags;
 999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1000                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1001                         ndr->flags = _flags_save_string;
1002                 }
1003                 {
1004                         uint32_t _flags_save_string = ndr->flags;
1005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1007                         ndr->flags = _flags_save_string;
1008                 }
1009                 {
1010                         uint32_t _flags_save_string = ndr->flags;
1011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1012                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1013                         ndr->flags = _flags_save_string;
1014                 }
1015                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1016                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1021                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1024         }
1025         if (ndr_flags & NDR_BUFFERS) {
1026                 {
1027                         uint32_t _flags_save_string = ndr->flags;
1028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1029                         if (r->servername) {
1030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1032                         }
1033                         ndr->flags = _flags_save_string;
1034                 }
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         if (r->printername) {
1039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1041                         }
1042                         ndr->flags = _flags_save_string;
1043                 }
1044                 {
1045                         uint32_t _flags_save_string = ndr->flags;
1046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1047                         if (r->sharename) {
1048                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1049                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1050                         }
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         if (r->portname) {
1057                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1058                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1059                         }
1060                         ndr->flags = _flags_save_string;
1061                 }
1062                 {
1063                         uint32_t _flags_save_string = ndr->flags;
1064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1065                         if (r->drivername) {
1066                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1067                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1068                         }
1069                         ndr->flags = _flags_save_string;
1070                 }
1071                 {
1072                         uint32_t _flags_save_string = ndr->flags;
1073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1074                         if (r->comment) {
1075                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1076                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1077                         }
1078                         ndr->flags = _flags_save_string;
1079                 }
1080                 {
1081                         uint32_t _flags_save_string = ndr->flags;
1082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1083                         if (r->location) {
1084                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1085                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1086                         }
1087                         ndr->flags = _flags_save_string;
1088                 }
1089                 if (r->devmode) {
1090                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1091                         {
1092                                 struct ndr_push *_ndr_devmode;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1094                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1096                         }
1097                 }
1098                 {
1099                         uint32_t _flags_save_string = ndr->flags;
1100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1101                         if (r->sepfile) {
1102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1104                         }
1105                         ndr->flags = _flags_save_string;
1106                 }
1107                 {
1108                         uint32_t _flags_save_string = ndr->flags;
1109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1110                         if (r->printprocessor) {
1111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1113                         }
1114                         ndr->flags = _flags_save_string;
1115                 }
1116                 {
1117                         uint32_t _flags_save_string = ndr->flags;
1118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1119                         if (r->datatype) {
1120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1122                         }
1123                         ndr->flags = _flags_save_string;
1124                 }
1125                 {
1126                         uint32_t _flags_save_string = ndr->flags;
1127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1128                         if (r->parameters) {
1129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1131                         }
1132                         ndr->flags = _flags_save_string;
1133                 }
1134                 if (r->secdesc) {
1135                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1136                         {
1137                                 struct ndr_push *_ndr_secdesc;
1138                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1139                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1140                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1141                         }
1142                 }
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1148 {
1149         uint32_t _ptr_servername;
1150         TALLOC_CTX *_mem_save_servername_0;
1151         uint32_t _ptr_printername;
1152         TALLOC_CTX *_mem_save_printername_0;
1153         uint32_t _ptr_sharename;
1154         TALLOC_CTX *_mem_save_sharename_0;
1155         uint32_t _ptr_portname;
1156         TALLOC_CTX *_mem_save_portname_0;
1157         uint32_t _ptr_drivername;
1158         TALLOC_CTX *_mem_save_drivername_0;
1159         uint32_t _ptr_comment;
1160         TALLOC_CTX *_mem_save_comment_0;
1161         uint32_t _ptr_location;
1162         TALLOC_CTX *_mem_save_location_0;
1163         uint32_t _ptr_devmode;
1164         TALLOC_CTX *_mem_save_devmode_0;
1165         uint32_t _ptr_sepfile;
1166         TALLOC_CTX *_mem_save_sepfile_0;
1167         uint32_t _ptr_printprocessor;
1168         TALLOC_CTX *_mem_save_printprocessor_0;
1169         uint32_t _ptr_datatype;
1170         TALLOC_CTX *_mem_save_datatype_0;
1171         uint32_t _ptr_parameters;
1172         TALLOC_CTX *_mem_save_parameters_0;
1173         uint32_t _ptr_secdesc;
1174         TALLOC_CTX *_mem_save_secdesc_0;
1175         if (ndr_flags & NDR_SCALARS) {
1176                 NDR_CHECK(ndr_pull_align(ndr, 4));
1177                 {
1178                         uint32_t _flags_save_string = ndr->flags;
1179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1181                         if (_ptr_servername) {
1182                                 NDR_PULL_ALLOC(ndr, r->servername);
1183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1184                         } else {
1185                                 r->servername = NULL;
1186                         }
1187                         ndr->flags = _flags_save_string;
1188                 }
1189                 {
1190                         uint32_t _flags_save_string = ndr->flags;
1191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1193                         if (_ptr_printername) {
1194                                 NDR_PULL_ALLOC(ndr, r->printername);
1195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1196                         } else {
1197                                 r->printername = NULL;
1198                         }
1199                         ndr->flags = _flags_save_string;
1200                 }
1201                 {
1202                         uint32_t _flags_save_string = ndr->flags;
1203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1205                         if (_ptr_sharename) {
1206                                 NDR_PULL_ALLOC(ndr, r->sharename);
1207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1208                         } else {
1209                                 r->sharename = NULL;
1210                         }
1211                         ndr->flags = _flags_save_string;
1212                 }
1213                 {
1214                         uint32_t _flags_save_string = ndr->flags;
1215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1217                         if (_ptr_portname) {
1218                                 NDR_PULL_ALLOC(ndr, r->portname);
1219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1220                         } else {
1221                                 r->portname = NULL;
1222                         }
1223                         ndr->flags = _flags_save_string;
1224                 }
1225                 {
1226                         uint32_t _flags_save_string = ndr->flags;
1227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1229                         if (_ptr_drivername) {
1230                                 NDR_PULL_ALLOC(ndr, r->drivername);
1231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1232                         } else {
1233                                 r->drivername = NULL;
1234                         }
1235                         ndr->flags = _flags_save_string;
1236                 }
1237                 {
1238                         uint32_t _flags_save_string = ndr->flags;
1239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1241                         if (_ptr_comment) {
1242                                 NDR_PULL_ALLOC(ndr, r->comment);
1243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1244                         } else {
1245                                 r->comment = NULL;
1246                         }
1247                         ndr->flags = _flags_save_string;
1248                 }
1249                 {
1250                         uint32_t _flags_save_string = ndr->flags;
1251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1253                         if (_ptr_location) {
1254                                 NDR_PULL_ALLOC(ndr, r->location);
1255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1256                         } else {
1257                                 r->location = NULL;
1258                         }
1259                         ndr->flags = _flags_save_string;
1260                 }
1261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1262                 if (_ptr_devmode) {
1263                         NDR_PULL_ALLOC(ndr, r->devmode);
1264                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1265                 } else {
1266                         r->devmode = NULL;
1267                 }
1268                 {
1269                         uint32_t _flags_save_string = ndr->flags;
1270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1271                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1272                         if (_ptr_sepfile) {
1273                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1274                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1275                         } else {
1276                                 r->sepfile = NULL;
1277                         }
1278                         ndr->flags = _flags_save_string;
1279                 }
1280                 {
1281                         uint32_t _flags_save_string = ndr->flags;
1282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1283                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1284                         if (_ptr_printprocessor) {
1285                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1286                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1287                         } else {
1288                                 r->printprocessor = NULL;
1289                         }
1290                         ndr->flags = _flags_save_string;
1291                 }
1292                 {
1293                         uint32_t _flags_save_string = ndr->flags;
1294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1295                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1296                         if (_ptr_datatype) {
1297                                 NDR_PULL_ALLOC(ndr, r->datatype);
1298                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1299                         } else {
1300                                 r->datatype = NULL;
1301                         }
1302                         ndr->flags = _flags_save_string;
1303                 }
1304                 {
1305                         uint32_t _flags_save_string = ndr->flags;
1306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1307                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1308                         if (_ptr_parameters) {
1309                                 NDR_PULL_ALLOC(ndr, r->parameters);
1310                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1311                         } else {
1312                                 r->parameters = NULL;
1313                         }
1314                         ndr->flags = _flags_save_string;
1315                 }
1316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1317                 if (_ptr_secdesc) {
1318                         NDR_PULL_ALLOC(ndr, r->secdesc);
1319                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1320                 } else {
1321                         r->secdesc = NULL;
1322                 }
1323                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1328                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1331         }
1332         if (ndr_flags & NDR_BUFFERS) {
1333                 {
1334                         uint32_t _flags_save_string = ndr->flags;
1335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1336                         if (r->servername) {
1337                                 uint32_t _relative_save_offset;
1338                                 _relative_save_offset = ndr->offset;
1339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1340                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1341                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1344                                 ndr->offset = _relative_save_offset;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         if (r->printername) {
1352                                 uint32_t _relative_save_offset;
1353                                 _relative_save_offset = ndr->offset;
1354                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1355                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1356                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1357                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1358                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1359                                 ndr->offset = _relative_save_offset;
1360                         }
1361                         ndr->flags = _flags_save_string;
1362                 }
1363                 {
1364                         uint32_t _flags_save_string = ndr->flags;
1365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1366                         if (r->sharename) {
1367                                 uint32_t _relative_save_offset;
1368                                 _relative_save_offset = ndr->offset;
1369                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1370                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1371                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1372                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1373                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1374                                 ndr->offset = _relative_save_offset;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         if (r->portname) {
1382                                 uint32_t _relative_save_offset;
1383                                 _relative_save_offset = ndr->offset;
1384                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1385                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1386                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1387                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1388                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1389                                 ndr->offset = _relative_save_offset;
1390                         }
1391                         ndr->flags = _flags_save_string;
1392                 }
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->drivername) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1400                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1404                                 ndr->offset = _relative_save_offset;
1405                         }
1406                         ndr->flags = _flags_save_string;
1407                 }
1408                 {
1409                         uint32_t _flags_save_string = ndr->flags;
1410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1411                         if (r->comment) {
1412                                 uint32_t _relative_save_offset;
1413                                 _relative_save_offset = ndr->offset;
1414                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1415                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1416                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1417                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1418                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1419                                 ndr->offset = _relative_save_offset;
1420                         }
1421                         ndr->flags = _flags_save_string;
1422                 }
1423                 {
1424                         uint32_t _flags_save_string = ndr->flags;
1425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1426                         if (r->location) {
1427                                 uint32_t _relative_save_offset;
1428                                 _relative_save_offset = ndr->offset;
1429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1430                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1431                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1434                                 ndr->offset = _relative_save_offset;
1435                         }
1436                         ndr->flags = _flags_save_string;
1437                 }
1438                 if (r->devmode) {
1439                         uint32_t _relative_save_offset;
1440                         _relative_save_offset = ndr->offset;
1441                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1442                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1443                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1444                         {
1445                                 struct ndr_pull *_ndr_devmode;
1446                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1447                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1448                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1449                         }
1450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1451                         ndr->offset = _relative_save_offset;
1452                 }
1453                 {
1454                         uint32_t _flags_save_string = ndr->flags;
1455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1456                         if (r->sepfile) {
1457                                 uint32_t _relative_save_offset;
1458                                 _relative_save_offset = ndr->offset;
1459                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1460                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1461                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1462                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1463                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1464                                 ndr->offset = _relative_save_offset;
1465                         }
1466                         ndr->flags = _flags_save_string;
1467                 }
1468                 {
1469                         uint32_t _flags_save_string = ndr->flags;
1470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1471                         if (r->printprocessor) {
1472                                 uint32_t _relative_save_offset;
1473                                 _relative_save_offset = ndr->offset;
1474                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1475                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1476                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1477                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1478                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1479                                 ndr->offset = _relative_save_offset;
1480                         }
1481                         ndr->flags = _flags_save_string;
1482                 }
1483                 {
1484                         uint32_t _flags_save_string = ndr->flags;
1485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1486                         if (r->datatype) {
1487                                 uint32_t _relative_save_offset;
1488                                 _relative_save_offset = ndr->offset;
1489                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1490                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1491                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1492                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1493                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1494                                 ndr->offset = _relative_save_offset;
1495                         }
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         if (r->parameters) {
1502                                 uint32_t _relative_save_offset;
1503                                 _relative_save_offset = ndr->offset;
1504                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1505                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1506                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1507                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1508                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1509                                 ndr->offset = _relative_save_offset;
1510                         }
1511                         ndr->flags = _flags_save_string;
1512                 }
1513                 if (r->secdesc) {
1514                         uint32_t _relative_save_offset;
1515                         _relative_save_offset = ndr->offset;
1516                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1517                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1518                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1519                         {
1520                                 struct ndr_pull *_ndr_secdesc;
1521                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1522                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1523                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1524                         }
1525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1526                         ndr->offset = _relative_save_offset;
1527                 }
1528         }
1529         return NDR_ERR_SUCCESS;
1530 }
1531
1532 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1533 {
1534         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1535         ndr->depth++;
1536         ndr_print_ptr(ndr, "servername", r->servername);
1537         ndr->depth++;
1538         if (r->servername) {
1539                 ndr_print_string(ndr, "servername", r->servername);
1540         }
1541         ndr->depth--;
1542         ndr_print_ptr(ndr, "printername", r->printername);
1543         ndr->depth++;
1544         if (r->printername) {
1545                 ndr_print_string(ndr, "printername", r->printername);
1546         }
1547         ndr->depth--;
1548         ndr_print_ptr(ndr, "sharename", r->sharename);
1549         ndr->depth++;
1550         if (r->sharename) {
1551                 ndr_print_string(ndr, "sharename", r->sharename);
1552         }
1553         ndr->depth--;
1554         ndr_print_ptr(ndr, "portname", r->portname);
1555         ndr->depth++;
1556         if (r->portname) {
1557                 ndr_print_string(ndr, "portname", r->portname);
1558         }
1559         ndr->depth--;
1560         ndr_print_ptr(ndr, "drivername", r->drivername);
1561         ndr->depth++;
1562         if (r->drivername) {
1563                 ndr_print_string(ndr, "drivername", r->drivername);
1564         }
1565         ndr->depth--;
1566         ndr_print_ptr(ndr, "comment", r->comment);
1567         ndr->depth++;
1568         if (r->comment) {
1569                 ndr_print_string(ndr, "comment", r->comment);
1570         }
1571         ndr->depth--;
1572         ndr_print_ptr(ndr, "location", r->location);
1573         ndr->depth++;
1574         if (r->location) {
1575                 ndr_print_string(ndr, "location", r->location);
1576         }
1577         ndr->depth--;
1578         ndr_print_ptr(ndr, "devmode", r->devmode);
1579         ndr->depth++;
1580         if (r->devmode) {
1581                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1582         }
1583         ndr->depth--;
1584         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1585         ndr->depth++;
1586         if (r->sepfile) {
1587                 ndr_print_string(ndr, "sepfile", r->sepfile);
1588         }
1589         ndr->depth--;
1590         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1591         ndr->depth++;
1592         if (r->printprocessor) {
1593                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1594         }
1595         ndr->depth--;
1596         ndr_print_ptr(ndr, "datatype", r->datatype);
1597         ndr->depth++;
1598         if (r->datatype) {
1599                 ndr_print_string(ndr, "datatype", r->datatype);
1600         }
1601         ndr->depth--;
1602         ndr_print_ptr(ndr, "parameters", r->parameters);
1603         ndr->depth++;
1604         if (r->parameters) {
1605                 ndr_print_string(ndr, "parameters", r->parameters);
1606         }
1607         ndr->depth--;
1608         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1609         ndr->depth++;
1610         if (r->secdesc) {
1611                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1612         }
1613         ndr->depth--;
1614         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1615         ndr_print_uint32(ndr, "priority", r->priority);
1616         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1617         ndr_print_uint32(ndr, "starttime", r->starttime);
1618         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1619         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1620         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1621         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1622         ndr->depth--;
1623 }
1624
1625 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1626 {
1627         if (ndr_flags & NDR_SCALARS) {
1628                 NDR_CHECK(ndr_push_align(ndr, 4));
1629                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1630         }
1631         if (ndr_flags & NDR_BUFFERS) {
1632                 if (r->secdesc) {
1633                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1634                         {
1635                                 struct ndr_push *_ndr_secdesc;
1636                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1637                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1638                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1639                         }
1640                 }
1641         }
1642         return NDR_ERR_SUCCESS;
1643 }
1644
1645 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1646 {
1647         uint32_t _ptr_secdesc;
1648         TALLOC_CTX *_mem_save_secdesc_0;
1649         if (ndr_flags & NDR_SCALARS) {
1650                 NDR_CHECK(ndr_pull_align(ndr, 4));
1651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1652                 if (_ptr_secdesc) {
1653                         NDR_PULL_ALLOC(ndr, r->secdesc);
1654                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1655                 } else {
1656                         r->secdesc = NULL;
1657                 }
1658         }
1659         if (ndr_flags & NDR_BUFFERS) {
1660                 if (r->secdesc) {
1661                         uint32_t _relative_save_offset;
1662                         _relative_save_offset = ndr->offset;
1663                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1664                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1665                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1666                         {
1667                                 struct ndr_pull *_ndr_secdesc;
1668                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1669                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1670                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1671                         }
1672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1673                         ndr->offset = _relative_save_offset;
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1680 {
1681         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1682         ndr->depth++;
1683         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1684         ndr->depth++;
1685         if (r->secdesc) {
1686                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1687         }
1688         ndr->depth--;
1689         ndr->depth--;
1690 }
1691
1692 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1693 {
1694         if (ndr_flags & NDR_SCALARS) {
1695                 NDR_CHECK(ndr_push_align(ndr, 4));
1696                 {
1697                         uint32_t _flags_save_string = ndr->flags;
1698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1699                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1700                         ndr->flags = _flags_save_string;
1701                 }
1702                 {
1703                         uint32_t _flags_save_string = ndr->flags;
1704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1705                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1706                         ndr->flags = _flags_save_string;
1707                 }
1708                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1709         }
1710         if (ndr_flags & NDR_BUFFERS) {
1711                 {
1712                         uint32_t _flags_save_string = ndr->flags;
1713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1714                         if (r->printername) {
1715                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1716                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1717                         }
1718                         ndr->flags = _flags_save_string;
1719                 }
1720                 {
1721                         uint32_t _flags_save_string = ndr->flags;
1722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1723                         if (r->servername) {
1724                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1725                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1726                         }
1727                         ndr->flags = _flags_save_string;
1728                 }
1729         }
1730         return NDR_ERR_SUCCESS;
1731 }
1732
1733 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1734 {
1735         uint32_t _ptr_printername;
1736         TALLOC_CTX *_mem_save_printername_0;
1737         uint32_t _ptr_servername;
1738         TALLOC_CTX *_mem_save_servername_0;
1739         if (ndr_flags & NDR_SCALARS) {
1740                 NDR_CHECK(ndr_pull_align(ndr, 4));
1741                 {
1742                         uint32_t _flags_save_string = ndr->flags;
1743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1745                         if (_ptr_printername) {
1746                                 NDR_PULL_ALLOC(ndr, r->printername);
1747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1748                         } else {
1749                                 r->printername = NULL;
1750                         }
1751                         ndr->flags = _flags_save_string;
1752                 }
1753                 {
1754                         uint32_t _flags_save_string = ndr->flags;
1755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1757                         if (_ptr_servername) {
1758                                 NDR_PULL_ALLOC(ndr, r->servername);
1759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1760                         } else {
1761                                 r->servername = NULL;
1762                         }
1763                         ndr->flags = _flags_save_string;
1764                 }
1765                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 {
1769                         uint32_t _flags_save_string = ndr->flags;
1770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1771                         if (r->printername) {
1772                                 uint32_t _relative_save_offset;
1773                                 _relative_save_offset = ndr->offset;
1774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1775                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1776                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1779                                 ndr->offset = _relative_save_offset;
1780                         }
1781                         ndr->flags = _flags_save_string;
1782                 }
1783                 {
1784                         uint32_t _flags_save_string = ndr->flags;
1785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1786                         if (r->servername) {
1787                                 uint32_t _relative_save_offset;
1788                                 _relative_save_offset = ndr->offset;
1789                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1790                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1791                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1792                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1793                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1794                                 ndr->offset = _relative_save_offset;
1795                         }
1796                         ndr->flags = _flags_save_string;
1797                 }
1798         }
1799         return NDR_ERR_SUCCESS;
1800 }
1801
1802 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1803 {
1804         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1805         ndr->depth++;
1806         ndr_print_ptr(ndr, "printername", r->printername);
1807         ndr->depth++;
1808         if (r->printername) {
1809                 ndr_print_string(ndr, "printername", r->printername);
1810         }
1811         ndr->depth--;
1812         ndr_print_ptr(ndr, "servername", r->servername);
1813         ndr->depth++;
1814         if (r->servername) {
1815                 ndr_print_string(ndr, "servername", r->servername);
1816         }
1817         ndr->depth--;
1818         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1819         ndr->depth--;
1820 }
1821
1822 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1823 {
1824         if (ndr_flags & NDR_SCALARS) {
1825                 NDR_CHECK(ndr_push_align(ndr, 4));
1826                 {
1827                         uint32_t _flags_save_string = ndr->flags;
1828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1829                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1830                         ndr->flags = _flags_save_string;
1831                 }
1832                 {
1833                         uint32_t _flags_save_string = ndr->flags;
1834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1835                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1836                         ndr->flags = _flags_save_string;
1837                 }
1838                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1841         }
1842         if (ndr_flags & NDR_BUFFERS) {
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         if (r->printername) {
1847                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1848                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1849                         }
1850                         ndr->flags = _flags_save_string;
1851                 }
1852                 {
1853                         uint32_t _flags_save_string = ndr->flags;
1854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1855                         if (r->portname) {
1856                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1858                         }
1859                         ndr->flags = _flags_save_string;
1860                 }
1861         }
1862         return NDR_ERR_SUCCESS;
1863 }
1864
1865 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1866 {
1867         uint32_t _ptr_printername;
1868         TALLOC_CTX *_mem_save_printername_0;
1869         uint32_t _ptr_portname;
1870         TALLOC_CTX *_mem_save_portname_0;
1871         if (ndr_flags & NDR_SCALARS) {
1872                 NDR_CHECK(ndr_pull_align(ndr, 4));
1873                 {
1874                         uint32_t _flags_save_string = ndr->flags;
1875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1876                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1877                         if (_ptr_printername) {
1878                                 NDR_PULL_ALLOC(ndr, r->printername);
1879                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1880                         } else {
1881                                 r->printername = NULL;
1882                         }
1883                         ndr->flags = _flags_save_string;
1884                 }
1885                 {
1886                         uint32_t _flags_save_string = ndr->flags;
1887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1888                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1889                         if (_ptr_portname) {
1890                                 NDR_PULL_ALLOC(ndr, r->portname);
1891                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1892                         } else {
1893                                 r->portname = NULL;
1894                         }
1895                         ndr->flags = _flags_save_string;
1896                 }
1897                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 {
1903                         uint32_t _flags_save_string = ndr->flags;
1904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1905                         if (r->printername) {
1906                                 uint32_t _relative_save_offset;
1907                                 _relative_save_offset = ndr->offset;
1908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1909                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1910                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1913                                 ndr->offset = _relative_save_offset;
1914                         }
1915                         ndr->flags = _flags_save_string;
1916                 }
1917                 {
1918                         uint32_t _flags_save_string = ndr->flags;
1919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1920                         if (r->portname) {
1921                                 uint32_t _relative_save_offset;
1922                                 _relative_save_offset = ndr->offset;
1923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1924                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1925                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1928                                 ndr->offset = _relative_save_offset;
1929                         }
1930                         ndr->flags = _flags_save_string;
1931                 }
1932         }
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1937 {
1938         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1939         ndr->depth++;
1940         ndr_print_ptr(ndr, "printername", r->printername);
1941         ndr->depth++;
1942         if (r->printername) {
1943                 ndr_print_string(ndr, "printername", r->printername);
1944         }
1945         ndr->depth--;
1946         ndr_print_ptr(ndr, "portname", r->portname);
1947         ndr->depth++;
1948         if (r->portname) {
1949                 ndr_print_string(ndr, "portname", r->portname);
1950         }
1951         ndr->depth--;
1952         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1953         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1954         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1955         ndr->depth--;
1956 }
1957
1958 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1959 {
1960         if (ndr_flags & NDR_SCALARS) {
1961                 NDR_CHECK(ndr_push_align(ndr, 4));
1962                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1963         }
1964         if (ndr_flags & NDR_BUFFERS) {
1965         }
1966         return NDR_ERR_SUCCESS;
1967 }
1968
1969 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
1970 {
1971         if (ndr_flags & NDR_SCALARS) {
1972                 NDR_CHECK(ndr_pull_align(ndr, 4));
1973                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1974         }
1975         if (ndr_flags & NDR_BUFFERS) {
1976         }
1977         return NDR_ERR_SUCCESS;
1978 }
1979
1980 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
1981 {
1982         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
1983         ndr->depth++;
1984         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1985         ndr->depth--;
1986 }
1987
1988 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1989 {
1990         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1991         return NDR_ERR_SUCCESS;
1992 }
1993
1994 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1995 {
1996         uint32_t v;
1997         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1998         *r = v;
1999         return NDR_ERR_SUCCESS;
2000 }
2001
2002 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2003 {
2004         ndr_print_uint32(ndr, name, r);
2005         ndr->depth++;
2006         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2007         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2008         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2009         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2010         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2011         ndr->depth--;
2012 }
2013
2014 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2015 {
2016         if (ndr_flags & NDR_SCALARS) {
2017                 NDR_CHECK(ndr_push_align(ndr, 4));
2018                 {
2019                         uint32_t _flags_save_string = ndr->flags;
2020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2022                         ndr->flags = _flags_save_string;
2023                 }
2024                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2025         }
2026         if (ndr_flags & NDR_BUFFERS) {
2027                 {
2028                         uint32_t _flags_save_string = ndr->flags;
2029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2030                         if (r->guid) {
2031                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2032                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2033                         }
2034                         ndr->flags = _flags_save_string;
2035                 }
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2041 {
2042         uint32_t _ptr_guid;
2043         TALLOC_CTX *_mem_save_guid_0;
2044         if (ndr_flags & NDR_SCALARS) {
2045                 NDR_CHECK(ndr_pull_align(ndr, 4));
2046                 {
2047                         uint32_t _flags_save_string = ndr->flags;
2048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2050                         if (_ptr_guid) {
2051                                 NDR_PULL_ALLOC(ndr, r->guid);
2052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2053                         } else {
2054                                 r->guid = NULL;
2055                         }
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 uint32_t _relative_save_offset;
2066                                 _relative_save_offset = ndr->offset;
2067                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2068                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2069                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2070                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2071                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2072                                 ndr->offset = _relative_save_offset;
2073                         }
2074                         ndr->flags = _flags_save_string;
2075                 }
2076         }
2077         return NDR_ERR_SUCCESS;
2078 }
2079
2080 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2081 {
2082         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2083         ndr->depth++;
2084         ndr_print_ptr(ndr, "guid", r->guid);
2085         ndr->depth++;
2086         if (r->guid) {
2087                 ndr_print_string(ndr, "guid", r->guid);
2088         }
2089         ndr->depth--;
2090         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2091         ndr->depth--;
2092 }
2093
2094 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2095 {
2096         if (ndr_flags & NDR_SCALARS) {
2097                 NDR_CHECK(ndr_push_align(ndr, 4));
2098                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2099         }
2100         if (ndr_flags & NDR_BUFFERS) {
2101                 if (r->devmode) {
2102                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2103                         {
2104                                 struct ndr_push *_ndr_devmode;
2105                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2106                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2107                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2108                         }
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2115 {
2116         uint32_t _ptr_devmode;
2117         TALLOC_CTX *_mem_save_devmode_0;
2118         if (ndr_flags & NDR_SCALARS) {
2119                 NDR_CHECK(ndr_pull_align(ndr, 4));
2120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2121                 if (_ptr_devmode) {
2122                         NDR_PULL_ALLOC(ndr, r->devmode);
2123                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2124                 } else {
2125                         r->devmode = NULL;
2126                 }
2127         }
2128         if (ndr_flags & NDR_BUFFERS) {
2129                 if (r->devmode) {
2130                         uint32_t _relative_save_offset;
2131                         _relative_save_offset = ndr->offset;
2132                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2133                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2134                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2135                         {
2136                                 struct ndr_pull *_ndr_devmode;
2137                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2138                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2139                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2140                         }
2141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2142                         ndr->offset = _relative_save_offset;
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2149 {
2150         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2151         ndr->depth++;
2152         ndr_print_ptr(ndr, "devmode", r->devmode);
2153         ndr->depth++;
2154         if (r->devmode) {
2155                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2156         }
2157         ndr->depth--;
2158         ndr->depth--;
2159 }
2160
2161 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2162 {
2163         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2164         if (ndr_flags & NDR_SCALARS) {
2165                 int level = ndr_push_get_switch_value(ndr, r);
2166                 switch (level) {
2167                         case 0: {
2168                                 NDR_CHECK(ndr_push_align(ndr, 4));
2169                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2170                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2171                         break; }
2172
2173                         case 1: {
2174                                 NDR_CHECK(ndr_push_align(ndr, 4));
2175                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2176                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2177                         break; }
2178
2179                         case 2: {
2180                                 NDR_CHECK(ndr_push_align(ndr, 4));
2181                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2182                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2183                         break; }
2184
2185                         case 3: {
2186                                 NDR_CHECK(ndr_push_align(ndr, 4));
2187                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2188                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2189                         break; }
2190
2191                         case 4: {
2192                                 NDR_CHECK(ndr_push_align(ndr, 4));
2193                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2194                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2195                         break; }
2196
2197                         case 5: {
2198                                 NDR_CHECK(ndr_push_align(ndr, 4));
2199                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2200                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2201                         break; }
2202
2203                         case 6: {
2204                                 NDR_CHECK(ndr_push_align(ndr, 4));
2205                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2206                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2207                         break; }
2208
2209                         case 7: {
2210                                 NDR_CHECK(ndr_push_align(ndr, 4));
2211                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2212                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2213                         break; }
2214
2215                         case 8: {
2216                                 NDR_CHECK(ndr_push_align(ndr, 4));
2217                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2218                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2219                         break; }
2220
2221                         case 9: {
2222                                 NDR_CHECK(ndr_push_align(ndr, 4));
2223                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2224                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2225                         break; }
2226
2227                         default: {
2228                         break; }
2229
2230                 }
2231         }
2232         if (ndr_flags & NDR_BUFFERS) {
2233                 int level = ndr_push_get_switch_value(ndr, r);
2234                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2235                 switch (level) {
2236                         case 0:
2237                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2238                         break;
2239
2240                         case 1:
2241                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2242                         break;
2243
2244                         case 2:
2245                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2246                         break;
2247
2248                         case 3:
2249                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2250                         break;
2251
2252                         case 4:
2253                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2254                         break;
2255
2256                         case 5:
2257                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2258                         break;
2259
2260                         case 6:
2261                         break;
2262
2263                         case 7:
2264                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2265                         break;
2266
2267                         case 8:
2268                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2269                         break;
2270
2271                         case 9:
2272                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2273                         break;
2274
2275                         default:
2276                         break;
2277
2278                 }
2279         }
2280         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2281         return NDR_ERR_SUCCESS;
2282 }
2283
2284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2285 {
2286         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2287         int level;
2288         level = ndr_pull_get_switch_value(ndr, r);
2289         if (ndr_flags & NDR_SCALARS) {
2290                 switch (level) {
2291                         case 0: {
2292                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2293                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2294                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2295                         break; }
2296
2297                         case 1: {
2298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2300                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2301                         break; }
2302
2303                         case 2: {
2304                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2305                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2306                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2307                         break; }
2308
2309                         case 3: {
2310                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2311                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2312                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2313                         break; }
2314
2315                         case 4: {
2316                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2317                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2318                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2319                         break; }
2320
2321                         case 5: {
2322                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2323                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2324                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2325                         break; }
2326
2327                         case 6: {
2328                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2329                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2330                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2331                         break; }
2332
2333                         case 7: {
2334                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2335                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2336                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2337                         break; }
2338
2339                         case 8: {
2340                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2341                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2342                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2343                         break; }
2344
2345                         case 9: {
2346                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2347                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2348                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2349                         break; }
2350
2351                         default: {
2352                         break; }
2353
2354                 }
2355         }
2356         if (ndr_flags & NDR_BUFFERS) {
2357                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2358                 switch (level) {
2359                         case 0:
2360                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2361                         break;
2362
2363                         case 1:
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2365                         break;
2366
2367                         case 2:
2368                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2369                         break;
2370
2371                         case 3:
2372                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2373                         break;
2374
2375                         case 4:
2376                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2377                         break;
2378
2379                         case 5:
2380                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2381                         break;
2382
2383                         case 6:
2384                         break;
2385
2386                         case 7:
2387                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2388                         break;
2389
2390                         case 8:
2391                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2392                         break;
2393
2394                         case 9:
2395                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2396                         break;
2397
2398                         default:
2399                         break;
2400
2401                 }
2402         }
2403         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2408 {
2409         int level;
2410         level = ndr_print_get_switch_value(ndr, r);
2411         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2412         switch (level) {
2413                 case 0:
2414                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2415                 break;
2416
2417                 case 1:
2418                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2419                 break;
2420
2421                 case 2:
2422                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2423                 break;
2424
2425                 case 3:
2426                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2427                 break;
2428
2429                 case 4:
2430                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2431                 break;
2432
2433                 case 5:
2434                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2435                 break;
2436
2437                 case 6:
2438                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2439                 break;
2440
2441                 case 7:
2442                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2443                 break;
2444
2445                 case 8:
2446                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2447                 break;
2448
2449                 case 9:
2450                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2451                 break;
2452
2453                 default:
2454                 break;
2455
2456         }
2457 }
2458
2459 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2460 {
2461         if (ndr_flags & NDR_SCALARS) {
2462                 NDR_CHECK(ndr_push_align(ndr, 4));
2463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2465         }
2466         if (ndr_flags & NDR_BUFFERS) {
2467                 if (r->devmode) {
2468                         {
2469                                 struct ndr_push *_ndr_devmode;
2470                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2471                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2472                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2473                         }
2474                 }
2475         }
2476         return NDR_ERR_SUCCESS;
2477 }
2478
2479 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2480 {
2481         uint32_t _ptr_devmode;
2482         TALLOC_CTX *_mem_save_devmode_0;
2483         if (ndr_flags & NDR_SCALARS) {
2484                 NDR_CHECK(ndr_pull_align(ndr, 4));
2485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2487                 if (_ptr_devmode) {
2488                         NDR_PULL_ALLOC(ndr, r->devmode);
2489                 } else {
2490                         r->devmode = NULL;
2491                 }
2492         }
2493         if (ndr_flags & NDR_BUFFERS) {
2494                 if (r->devmode) {
2495                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2496                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2497                         {
2498                                 struct ndr_pull *_ndr_devmode;
2499                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2500                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2501                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2502                         }
2503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2504                 }
2505         }
2506         return NDR_ERR_SUCCESS;
2507 }
2508
2509 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2510 {
2511         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2512         ndr->depth++;
2513         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);
2514         ndr_print_ptr(ndr, "devmode", r->devmode);
2515         ndr->depth++;
2516         if (r->devmode) {
2517                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2518         }
2519         ndr->depth--;
2520         ndr->depth--;
2521 }
2522
2523 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2524 {
2525         if (ndr_flags & NDR_SCALARS) {
2526                 NDR_CHECK(ndr_push_align(ndr, 4));
2527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2528                 {
2529                         uint32_t _flags_save_string = ndr->flags;
2530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2532                         ndr->flags = _flags_save_string;
2533                 }
2534                 {
2535                         uint32_t _flags_save_string = ndr->flags;
2536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2538                         ndr->flags = _flags_save_string;
2539                 }
2540                 {
2541                         uint32_t _flags_save_string = ndr->flags;
2542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2544                         ndr->flags = _flags_save_string;
2545                 }
2546                 {
2547                         uint32_t _flags_save_string = ndr->flags;
2548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2550                         ndr->flags = _flags_save_string;
2551                 }
2552                 {
2553                         uint32_t _flags_save_string = ndr->flags;
2554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2556                         ndr->flags = _flags_save_string;
2557                 }
2558                 {
2559                         uint32_t _flags_save_string = ndr->flags;
2560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2562                         ndr->flags = _flags_save_string;
2563                 }
2564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
2565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2569                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2570         }
2571         if (ndr_flags & NDR_BUFFERS) {
2572                 {
2573                         uint32_t _flags_save_string = ndr->flags;
2574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2575                         if (r->printer_name) {
2576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2578                         }
2579                         ndr->flags = _flags_save_string;
2580                 }
2581                 {
2582                         uint32_t _flags_save_string = ndr->flags;
2583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2584                         if (r->server_name) {
2585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2587                         }
2588                         ndr->flags = _flags_save_string;
2589                 }
2590                 {
2591                         uint32_t _flags_save_string = ndr->flags;
2592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2593                         if (r->user_name) {
2594                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2596                         }
2597                         ndr->flags = _flags_save_string;
2598                 }
2599                 {
2600                         uint32_t _flags_save_string = ndr->flags;
2601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2602                         if (r->document_name) {
2603                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2605                         }
2606                         ndr->flags = _flags_save_string;
2607                 }
2608                 {
2609                         uint32_t _flags_save_string = ndr->flags;
2610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2611                         if (r->data_type) {
2612                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2613                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2614                         }
2615                         ndr->flags = _flags_save_string;
2616                 }
2617                 {
2618                         uint32_t _flags_save_string = ndr->flags;
2619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2620                         if (r->text_status) {
2621                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2622                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2623                         }
2624                         ndr->flags = _flags_save_string;
2625                 }
2626         }
2627         return NDR_ERR_SUCCESS;
2628 }
2629
2630 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2631 {
2632         uint32_t _ptr_printer_name;
2633         TALLOC_CTX *_mem_save_printer_name_0;
2634         uint32_t _ptr_server_name;
2635         TALLOC_CTX *_mem_save_server_name_0;
2636         uint32_t _ptr_user_name;
2637         TALLOC_CTX *_mem_save_user_name_0;
2638         uint32_t _ptr_document_name;
2639         TALLOC_CTX *_mem_save_document_name_0;
2640         uint32_t _ptr_data_type;
2641         TALLOC_CTX *_mem_save_data_type_0;
2642         uint32_t _ptr_text_status;
2643         TALLOC_CTX *_mem_save_text_status_0;
2644         if (ndr_flags & NDR_SCALARS) {
2645                 NDR_CHECK(ndr_pull_align(ndr, 4));
2646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2647                 {
2648                         uint32_t _flags_save_string = ndr->flags;
2649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2651                         if (_ptr_printer_name) {
2652                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2654                         } else {
2655                                 r->printer_name = NULL;
2656                         }
2657                         ndr->flags = _flags_save_string;
2658                 }
2659                 {
2660                         uint32_t _flags_save_string = ndr->flags;
2661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2663                         if (_ptr_server_name) {
2664                                 NDR_PULL_ALLOC(ndr, r->server_name);
2665                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2666                         } else {
2667                                 r->server_name = NULL;
2668                         }
2669                         ndr->flags = _flags_save_string;
2670                 }
2671                 {
2672                         uint32_t _flags_save_string = ndr->flags;
2673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2674                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2675                         if (_ptr_user_name) {
2676                                 NDR_PULL_ALLOC(ndr, r->user_name);
2677                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2678                         } else {
2679                                 r->user_name = NULL;
2680                         }
2681                         ndr->flags = _flags_save_string;
2682                 }
2683                 {
2684                         uint32_t _flags_save_string = ndr->flags;
2685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2687                         if (_ptr_document_name) {
2688                                 NDR_PULL_ALLOC(ndr, r->document_name);
2689                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2690                         } else {
2691                                 r->document_name = NULL;
2692                         }
2693                         ndr->flags = _flags_save_string;
2694                 }
2695                 {
2696                         uint32_t _flags_save_string = ndr->flags;
2697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2698                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2699                         if (_ptr_data_type) {
2700                                 NDR_PULL_ALLOC(ndr, r->data_type);
2701                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2702                         } else {
2703                                 r->data_type = NULL;
2704                         }
2705                         ndr->flags = _flags_save_string;
2706                 }
2707                 {
2708                         uint32_t _flags_save_string = ndr->flags;
2709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2710                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2711                         if (_ptr_text_status) {
2712                                 NDR_PULL_ALLOC(ndr, r->text_status);
2713                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2714                         } else {
2715                                 r->text_status = NULL;
2716                         }
2717                         ndr->flags = _flags_save_string;
2718                 }
2719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
2720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2724                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2725         }
2726         if (ndr_flags & NDR_BUFFERS) {
2727                 {
2728                         uint32_t _flags_save_string = ndr->flags;
2729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2730                         if (r->printer_name) {
2731                                 uint32_t _relative_save_offset;
2732                                 _relative_save_offset = ndr->offset;
2733                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2734                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2735                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2736                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2737                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2738                                 ndr->offset = _relative_save_offset;
2739                         }
2740                         ndr->flags = _flags_save_string;
2741                 }
2742                 {
2743                         uint32_t _flags_save_string = ndr->flags;
2744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2745                         if (r->server_name) {
2746                                 uint32_t _relative_save_offset;
2747                                 _relative_save_offset = ndr->offset;
2748                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2749                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2750                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2751                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2752                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2753                                 ndr->offset = _relative_save_offset;
2754                         }
2755                         ndr->flags = _flags_save_string;
2756                 }
2757                 {
2758                         uint32_t _flags_save_string = ndr->flags;
2759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2760                         if (r->user_name) {
2761                                 uint32_t _relative_save_offset;
2762                                 _relative_save_offset = ndr->offset;
2763                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2764                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2765                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2766                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2767                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2768                                 ndr->offset = _relative_save_offset;
2769                         }
2770                         ndr->flags = _flags_save_string;
2771                 }
2772                 {
2773                         uint32_t _flags_save_string = ndr->flags;
2774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2775                         if (r->document_name) {
2776                                 uint32_t _relative_save_offset;
2777                                 _relative_save_offset = ndr->offset;
2778                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2779                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2780                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2781                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2782                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2783                                 ndr->offset = _relative_save_offset;
2784                         }
2785                         ndr->flags = _flags_save_string;
2786                 }
2787                 {
2788                         uint32_t _flags_save_string = ndr->flags;
2789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2790                         if (r->data_type) {
2791                                 uint32_t _relative_save_offset;
2792                                 _relative_save_offset = ndr->offset;
2793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2794                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2795                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2798                                 ndr->offset = _relative_save_offset;
2799                         }
2800                         ndr->flags = _flags_save_string;
2801                 }
2802                 {
2803                         uint32_t _flags_save_string = ndr->flags;
2804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2805                         if (r->text_status) {
2806                                 uint32_t _relative_save_offset;
2807                                 _relative_save_offset = ndr->offset;
2808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2809                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2810                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2813                                 ndr->offset = _relative_save_offset;
2814                         }
2815                         ndr->flags = _flags_save_string;
2816                 }
2817         }
2818         return NDR_ERR_SUCCESS;
2819 }
2820
2821 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2822 {
2823         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2824         ndr->depth++;
2825         ndr_print_uint32(ndr, "job_id", r->job_id);
2826         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2827         ndr->depth++;
2828         if (r->printer_name) {
2829                 ndr_print_string(ndr, "printer_name", r->printer_name);
2830         }
2831         ndr->depth--;
2832         ndr_print_ptr(ndr, "server_name", r->server_name);
2833         ndr->depth++;
2834         if (r->server_name) {
2835                 ndr_print_string(ndr, "server_name", r->server_name);
2836         }
2837         ndr->depth--;
2838         ndr_print_ptr(ndr, "user_name", r->user_name);
2839         ndr->depth++;
2840         if (r->user_name) {
2841                 ndr_print_string(ndr, "user_name", r->user_name);
2842         }
2843         ndr->depth--;
2844         ndr_print_ptr(ndr, "document_name", r->document_name);
2845         ndr->depth++;
2846         if (r->document_name) {
2847                 ndr_print_string(ndr, "document_name", r->document_name);
2848         }
2849         ndr->depth--;
2850         ndr_print_ptr(ndr, "data_type", r->data_type);
2851         ndr->depth++;
2852         if (r->data_type) {
2853                 ndr_print_string(ndr, "data_type", r->data_type);
2854         }
2855         ndr->depth--;
2856         ndr_print_ptr(ndr, "text_status", r->text_status);
2857         ndr->depth++;
2858         if (r->text_status) {
2859                 ndr_print_string(ndr, "text_status", r->text_status);
2860         }
2861         ndr->depth--;
2862         ndr_print_uint32(ndr, "status", r->status);
2863         ndr_print_uint32(ndr, "priority", r->priority);
2864         ndr_print_uint32(ndr, "position", r->position);
2865         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2866         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2867         ndr_print_spoolss_Time(ndr, "time", &r->time);
2868         ndr->depth--;
2869 }
2870
2871 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
2872 {
2873         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2874         if (ndr_flags & NDR_SCALARS) {
2875                 int level = ndr_push_get_switch_value(ndr, r);
2876                 switch (level) {
2877                         case 1: {
2878                                 NDR_CHECK(ndr_push_align(ndr, 4));
2879                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2880                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2881                         break; }
2882
2883                         case 2: {
2884                         break; }
2885
2886                         case 3: {
2887                         break; }
2888
2889                         default: {
2890                         break; }
2891
2892                 }
2893         }
2894         if (ndr_flags & NDR_BUFFERS) {
2895                 int level = ndr_push_get_switch_value(ndr, r);
2896                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2897                 switch (level) {
2898                         case 1:
2899                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2900                         break;
2901
2902                         case 2:
2903                         break;
2904
2905                         case 3:
2906                         break;
2907
2908                         default:
2909                         break;
2910
2911                 }
2912         }
2913         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2914         return NDR_ERR_SUCCESS;
2915 }
2916
2917 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
2918 {
2919         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2920         int level;
2921         level = ndr_pull_get_switch_value(ndr, r);
2922         if (ndr_flags & NDR_SCALARS) {
2923                 switch (level) {
2924                         case 1: {
2925                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2926                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2927                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2928                         break; }
2929
2930                         case 2: {
2931                         break; }
2932
2933                         case 3: {
2934                         break; }
2935
2936                         default: {
2937                         break; }
2938
2939                 }
2940         }
2941         if (ndr_flags & NDR_BUFFERS) {
2942                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2943                 switch (level) {
2944                         case 1:
2945                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2946                         break;
2947
2948                         case 2:
2949                         break;
2950
2951                         case 3:
2952                         break;
2953
2954                         default:
2955                         break;
2956
2957                 }
2958         }
2959         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2960         return NDR_ERR_SUCCESS;
2961 }
2962
2963 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
2964 {
2965         int level;
2966         level = ndr_print_get_switch_value(ndr, r);
2967         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
2968         switch (level) {
2969                 case 1:
2970                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
2971                 break;
2972
2973                 case 2:
2974                 break;
2975
2976                 case 3:
2977                 break;
2978
2979                 default:
2980                 break;
2981
2982         }
2983 }
2984
2985 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
2986 {
2987         if (ndr_flags & NDR_SCALARS) {
2988                 NDR_CHECK(ndr_push_align(ndr, 4));
2989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
2990                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
2991                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
2992         }
2993         if (ndr_flags & NDR_BUFFERS) {
2994                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
2995         }
2996         return NDR_ERR_SUCCESS;
2997 }
2998
2999 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
3000 {
3001         if (ndr_flags & NDR_SCALARS) {
3002                 NDR_CHECK(ndr_pull_align(ndr, 4));
3003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3004                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
3005                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
3009         }
3010         return NDR_ERR_SUCCESS;
3011 }
3012
3013 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
3014 {
3015         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
3016         ndr->depth++;
3017         ndr_print_uint32(ndr, "level", r->level);
3018         ndr_print_set_switch_value(ndr, &r->info, r->level);
3019         ndr_print_spoolss_JobInfo(ndr, "info", &r->info);
3020         ndr->depth--;
3021 }
3022
3023 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
3024 {
3025         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3026         return NDR_ERR_SUCCESS;
3027 }
3028
3029 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
3030 {
3031         uint32_t v;
3032         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3033         *r = v;
3034         return NDR_ERR_SUCCESS;
3035 }
3036
3037 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
3038 {
3039         const char *val = NULL;
3040
3041         switch (r) {
3042                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
3043                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
3044                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
3045                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
3046                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
3047                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
3048                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
3049         }
3050         ndr_print_enum(ndr, name, "ENUM", val, r);
3051 }
3052
3053 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
3054 {
3055         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3056         return NDR_ERR_SUCCESS;
3057 }
3058
3059 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
3060 {
3061         uint32_t v;
3062         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3063         *r = v;
3064         return NDR_ERR_SUCCESS;
3065 }
3066
3067 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
3068 {
3069         const char *val = NULL;
3070
3071         switch (r) {
3072                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
3073                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
3074                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
3075                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
3076                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
3077         }
3078         ndr_print_enum(ndr, name, "ENUM", val, r);
3079 }
3080
3081 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
3082 {
3083         if (ndr_flags & NDR_SCALARS) {
3084                 NDR_CHECK(ndr_push_align(ndr, 4));
3085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
3089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
3090                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
3092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
3094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
3095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
3096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
3097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
3098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
3099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
3100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
3101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
3102                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
3103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
3104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
3105                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
3106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
3107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
3108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
3109                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
3110                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
3111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
3112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
3113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
3114         }
3115         if (ndr_flags & NDR_BUFFERS) {
3116                 if (r->servername) {
3117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3121                 }
3122                 if (r->printername) {
3123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
3133 {
3134         uint32_t _ptr_servername;
3135         TALLOC_CTX *_mem_save_servername_0;
3136         uint32_t _ptr_printername;
3137         TALLOC_CTX *_mem_save_printername_0;
3138         if (ndr_flags & NDR_SCALARS) {
3139                 NDR_CHECK(ndr_pull_align(ndr, 4));
3140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3141                 if (_ptr_servername) {
3142                         NDR_PULL_ALLOC(ndr, r->servername);
3143                 } else {
3144                         r->servername = NULL;
3145                 }
3146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3147                 if (_ptr_printername) {
3148                         NDR_PULL_ALLOC(ndr, r->printername);
3149                 } else {
3150                         r->printername = NULL;
3151                 }
3152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
3154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
3155                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
3156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
3157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
3159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
3160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
3161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
3162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
3163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
3164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
3165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
3166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
3167                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
3168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
3169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
3170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
3171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
3172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
3173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
3174                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
3175                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
3176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
3177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
3178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
3179         }
3180         if (ndr_flags & NDR_BUFFERS) {
3181                 if (r->servername) {
3182                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3183                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3186                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3187                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3188                         }
3189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3192                 }
3193                 if (r->printername) {
3194                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3195                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3198                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3200                         }
3201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3204                 }
3205         }
3206         return NDR_ERR_SUCCESS;
3207 }
3208
3209 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
3210 {
3211         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
3212         ndr->depth++;
3213         ndr_print_ptr(ndr, "servername", r->servername);
3214         ndr->depth++;
3215         if (r->servername) {
3216                 ndr_print_string(ndr, "servername", r->servername);
3217         }
3218         ndr->depth--;
3219         ndr_print_ptr(ndr, "printername", r->printername);
3220         ndr->depth++;
3221         if (r->printername) {
3222                 ndr_print_string(ndr, "printername", r->printername);
3223         }
3224         ndr->depth--;
3225         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3226         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
3227         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
3228         ndr_print_spoolss_Time(ndr, "time", &r->time);
3229         ndr_print_uint32(ndr, "global_counter", r->global_counter);
3230         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3231         ndr_print_uint32(ndr, "version", r->version);
3232         ndr_print_uint32(ndr, "free_build", r->free_build);
3233         ndr_print_uint32(ndr, "spooling", r->spooling);
3234         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
3235         ndr_print_uint32(ndr, "session_counter", r->session_counter);
3236         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
3237         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
3238         ndr_print_uint32(ndr, "job_error", r->job_error);
3239         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
3240         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
3241         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
3242         ndr_print_uint32(ndr, "change_id", r->change_id);
3243         ndr_print_WERROR(ndr, "last_error", r->last_error);
3244         ndr_print_uint32(ndr, "status", r->status);
3245         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
3246         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
3247         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
3248         ndr_print_uint16(ndr, "processor_level", r->processor_level);
3249         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
3250         ndr_print_uint32(ndr, "reserved2", r->reserved2);
3251         ndr_print_uint32(ndr, "reserved3", r->reserved3);
3252         ndr->depth--;
3253 }
3254
3255 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
3256 {
3257         if (ndr_flags & NDR_SCALARS) {
3258                 NDR_CHECK(ndr_push_align(ndr, 4));
3259                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
3260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
3261                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
3262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3263         }
3264         if (ndr_flags & NDR_BUFFERS) {
3265                 if (r->name) {
3266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
3269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3270                 }
3271                 if (r->description) {
3272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
3275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3276                 }
3277                 if (r->comment) {
3278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3282                 }
3283         }
3284         return NDR_ERR_SUCCESS;
3285 }
3286
3287 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
3288 {
3289         uint32_t _ptr_name;
3290         TALLOC_CTX *_mem_save_name_0;
3291         uint32_t _ptr_description;
3292         TALLOC_CTX *_mem_save_description_0;
3293         uint32_t _ptr_comment;
3294         TALLOC_CTX *_mem_save_comment_0;
3295         if (ndr_flags & NDR_SCALARS) {
3296                 NDR_CHECK(ndr_pull_align(ndr, 4));
3297                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
3298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
3299                 if (_ptr_name) {
3300                         NDR_PULL_ALLOC(ndr, r->name);
3301                 } else {
3302                         r->name = NULL;
3303                 }
3304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
3305                 if (_ptr_description) {
3306                         NDR_PULL_ALLOC(ndr, r->description);
3307                 } else {
3308                         r->description = NULL;
3309                 }
3310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3311                 if (_ptr_comment) {
3312                         NDR_PULL_ALLOC(ndr, r->comment);
3313                 } else {
3314                         r->comment = NULL;
3315                 }
3316         }
3317         if (ndr_flags & NDR_BUFFERS) {
3318                 if (r->name) {
3319                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3320                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
3321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
3322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
3323                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
3324                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
3325                         }
3326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
3327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
3328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
3329                 }
3330                 if (r->description) {
3331                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
3332                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
3333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
3334                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
3335                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
3336                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
3337                         }
3338                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
3339                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
3340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
3341                 }
3342                 if (r->comment) {
3343                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3347                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3349                         }
3350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3353                 }
3354         }
3355         return NDR_ERR_SUCCESS;
3356 }
3357
3358 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
3359 {
3360         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
3361         ndr->depth++;
3362         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
3363         ndr_print_ptr(ndr, "name", r->name);
3364         ndr->depth++;
3365         if (r->name) {
3366                 ndr_print_string(ndr, "name", r->name);
3367         }
3368         ndr->depth--;
3369         ndr_print_ptr(ndr, "description", r->description);
3370         ndr->depth++;
3371         if (r->description) {
3372                 ndr_print_string(ndr, "description", r->description);
3373         }
3374         ndr->depth--;
3375         ndr_print_ptr(ndr, "comment", r->comment);
3376         ndr->depth++;
3377         if (r->comment) {
3378                 ndr_print_string(ndr, "comment", r->comment);
3379         }
3380         ndr->depth--;
3381         ndr->depth--;
3382 }
3383
3384 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
3385 {
3386         if (ndr_flags & NDR_SCALARS) {
3387                 NDR_CHECK(ndr_push_align(ndr, 4));
3388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
3391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
3392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
3393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
3394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
3395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
3397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
3398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
3399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
3400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3401                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
3404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
3405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
3406                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
3407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
3408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
3409         }
3410         if (ndr_flags & NDR_BUFFERS) {
3411                 if (r->servername) {
3412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3416                 }
3417                 if (r->printername) {
3418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3422                 }
3423                 if (r->sharename) {
3424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
3427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3428                 }
3429                 if (r->portname) {
3430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
3433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3434                 }
3435                 if (r->drivername) {
3436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
3439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3440                 }
3441                 if (r->comment) {
3442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
3445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3446                 }
3447                 if (r->location) {
3448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
3451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3452                 }
3453                 if (r->devmode) {
3454                         {
3455                                 struct ndr_push *_ndr_devmode;
3456                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3457                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3458                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3459                         }
3460                 }
3461                 if (r->sepfile) {
3462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
3465                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3466                 }
3467                 if (r->printprocessor) {
3468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
3471                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3472                 }
3473                 if (r->datatype) {
3474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
3477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3478                 }
3479                 if (r->parameters) {
3480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
3483                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3484                 }
3485                 if (r->secdesc) {
3486                         {
3487                                 struct ndr_push *_ndr_secdesc;
3488                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3489                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3490                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3491                         }
3492                 }
3493         }
3494         return NDR_ERR_SUCCESS;
3495 }
3496
3497 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
3498 {
3499         uint32_t _ptr_servername;
3500         TALLOC_CTX *_mem_save_servername_0;
3501         uint32_t _ptr_printername;
3502         TALLOC_CTX *_mem_save_printername_0;
3503         uint32_t _ptr_sharename;
3504         TALLOC_CTX *_mem_save_sharename_0;
3505         uint32_t _ptr_portname;
3506         TALLOC_CTX *_mem_save_portname_0;
3507         uint32_t _ptr_drivername;
3508         TALLOC_CTX *_mem_save_drivername_0;
3509         uint32_t _ptr_comment;
3510         TALLOC_CTX *_mem_save_comment_0;
3511         uint32_t _ptr_location;
3512         TALLOC_CTX *_mem_save_location_0;
3513         uint32_t _ptr_devmode;
3514         TALLOC_CTX *_mem_save_devmode_0;
3515         uint32_t _ptr_sepfile;
3516         TALLOC_CTX *_mem_save_sepfile_0;
3517         uint32_t _ptr_printprocessor;
3518         TALLOC_CTX *_mem_save_printprocessor_0;
3519         uint32_t _ptr_datatype;
3520         TALLOC_CTX *_mem_save_datatype_0;
3521         uint32_t _ptr_parameters;
3522         TALLOC_CTX *_mem_save_parameters_0;
3523         uint32_t _ptr_secdesc;
3524         TALLOC_CTX *_mem_save_secdesc_0;
3525         if (ndr_flags & NDR_SCALARS) {
3526                 NDR_CHECK(ndr_pull_align(ndr, 4));
3527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3528                 if (_ptr_servername) {
3529                         NDR_PULL_ALLOC(ndr, r->servername);
3530                 } else {
3531                         r->servername = NULL;
3532                 }
3533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3534                 if (_ptr_printername) {
3535                         NDR_PULL_ALLOC(ndr, r->printername);
3536                 } else {
3537                         r->printername = NULL;
3538                 }
3539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
3540                 if (_ptr_sharename) {
3541                         NDR_PULL_ALLOC(ndr, r->sharename);
3542                 } else {
3543                         r->sharename = NULL;
3544                 }
3545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
3546                 if (_ptr_portname) {
3547                         NDR_PULL_ALLOC(ndr, r->portname);
3548                 } else {
3549                         r->portname = NULL;
3550                 }
3551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
3552                 if (_ptr_drivername) {
3553                         NDR_PULL_ALLOC(ndr, r->drivername);
3554                 } else {
3555                         r->drivername = NULL;
3556                 }
3557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
3558                 if (_ptr_comment) {
3559                         NDR_PULL_ALLOC(ndr, r->comment);
3560                 } else {
3561                         r->comment = NULL;
3562                 }
3563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
3564                 if (_ptr_location) {
3565                         NDR_PULL_ALLOC(ndr, r->location);
3566                 } else {
3567                         r->location = NULL;
3568                 }
3569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3570                 if (_ptr_devmode) {
3571                         NDR_PULL_ALLOC(ndr, r->devmode);
3572                 } else {
3573                         r->devmode = NULL;
3574                 }
3575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
3576                 if (_ptr_sepfile) {
3577                         NDR_PULL_ALLOC(ndr, r->sepfile);
3578                 } else {
3579                         r->sepfile = NULL;
3580                 }
3581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
3582                 if (_ptr_printprocessor) {
3583                         NDR_PULL_ALLOC(ndr, r->printprocessor);
3584                 } else {
3585                         r->printprocessor = NULL;
3586                 }
3587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
3588                 if (_ptr_datatype) {
3589                         NDR_PULL_ALLOC(ndr, r->datatype);
3590                 } else {
3591                         r->datatype = NULL;
3592                 }
3593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3594                 if (_ptr_parameters) {
3595                         NDR_PULL_ALLOC(ndr, r->parameters);
3596                 } else {
3597                         r->parameters = NULL;
3598                 }
3599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3600                 if (_ptr_secdesc) {
3601                         NDR_PULL_ALLOC(ndr, r->secdesc);
3602                 } else {
3603                         r->secdesc = NULL;
3604                 }
3605                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
3608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
3609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
3610                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
3611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
3612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
3613         }
3614         if (ndr_flags & NDR_BUFFERS) {
3615                 if (r->servername) {
3616                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3617                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3620                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3621                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3622                         }
3623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3624                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3626                 }
3627                 if (r->printername) {
3628                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3629                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3632                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3633                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3634                         }
3635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3636                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3638                 }
3639                 if (r->sharename) {
3640                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
3641                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
3642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
3643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
3644                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
3645                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
3646                         }
3647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
3648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
3649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
3650                 }
3651                 if (r->portname) {
3652                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3653                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
3654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
3655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
3656                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
3657                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
3658                         }
3659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
3660                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
3661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
3662                 }
3663                 if (r->drivername) {
3664                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3665                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
3666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
3667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
3668                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
3669                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
3670                         }
3671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
3672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
3673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
3674                 }
3675                 if (r->comment) {
3676                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
3677                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
3678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
3679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
3680                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
3681                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
3682                         }
3683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
3684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
3685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
3686                 }
3687                 if (r->location) {
3688                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
3689                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
3690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
3691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
3692                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
3693                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
3694                         }
3695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
3696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
3697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
3698                 }
3699                 if (r->devmode) {
3700                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3701                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3702                         {
3703                                 struct ndr_pull *_ndr_devmode;
3704                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3705                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3706                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
3707                         }
3708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3709                 }
3710                 if (r->sepfile) {
3711                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
3712                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
3713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
3714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
3715                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
3716                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
3717                         }
3718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
3719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
3720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
3721                 }
3722                 if (r->printprocessor) {
3723                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3724                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
3725                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
3726                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
3727                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
3728                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
3729                         }
3730                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
3731                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
3732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
3733                 }
3734                 if (r->datatype) {
3735                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
3736                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
3737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
3738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
3739                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
3740                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
3741                         }
3742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
3743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
3744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
3745                 }
3746                 if (r->parameters) {
3747                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3748                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3749                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
3750                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
3751                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
3752                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
3753                         }
3754                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
3755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
3756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3757                 }
3758                 if (r->secdesc) {
3759                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3760                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3761                         {
3762                                 struct ndr_pull *_ndr_secdesc;
3763                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3764                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3765                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3766                         }
3767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3768                 }
3769         }
3770         return NDR_ERR_SUCCESS;
3771 }
3772
3773 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
3774 {
3775         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
3776         ndr->depth++;
3777         ndr_print_ptr(ndr, "servername", r->servername);
3778         ndr->depth++;
3779         if (r->servername) {
3780                 ndr_print_string(ndr, "servername", r->servername);
3781         }
3782         ndr->depth--;
3783         ndr_print_ptr(ndr, "printername", r->printername);
3784         ndr->depth++;
3785         if (r->printername) {
3786                 ndr_print_string(ndr, "printername", r->printername);
3787         }
3788         ndr->depth--;
3789         ndr_print_ptr(ndr, "sharename", r->sharename);
3790         ndr->depth++;
3791         if (r->sharename) {
3792                 ndr_print_string(ndr, "sharename", r->sharename);
3793         }
3794         ndr->depth--;
3795         ndr_print_ptr(ndr, "portname", r->portname);
3796         ndr->depth++;
3797         if (r->portname) {
3798                 ndr_print_string(ndr, "portname", r->portname);
3799         }
3800         ndr->depth--;
3801         ndr_print_ptr(ndr, "drivername", r->drivername);
3802         ndr->depth++;
3803         if (r->drivername) {
3804                 ndr_print_string(ndr, "drivername", r->drivername);
3805         }
3806         ndr->depth--;
3807         ndr_print_ptr(ndr, "comment", r->comment);
3808         ndr->depth++;
3809         if (r->comment) {
3810                 ndr_print_string(ndr, "comment", r->comment);
3811         }
3812         ndr->depth--;
3813         ndr_print_ptr(ndr, "location", r->location);
3814         ndr->depth++;
3815         if (r->location) {
3816                 ndr_print_string(ndr, "location", r->location);
3817         }
3818         ndr->depth--;
3819         ndr_print_ptr(ndr, "devmode", r->devmode);
3820         ndr->depth++;
3821         if (r->devmode) {
3822                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3823         }
3824         ndr->depth--;
3825         ndr_print_ptr(ndr, "sepfile", r->sepfile);
3826         ndr->depth++;
3827         if (r->sepfile) {
3828                 ndr_print_string(ndr, "sepfile", r->sepfile);
3829         }
3830         ndr->depth--;
3831         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
3832         ndr->depth++;
3833         if (r->printprocessor) {
3834                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
3835         }
3836         ndr->depth--;
3837         ndr_print_ptr(ndr, "datatype", r->datatype);
3838         ndr->depth++;
3839         if (r->datatype) {
3840                 ndr_print_string(ndr, "datatype", r->datatype);
3841         }
3842         ndr->depth--;
3843         ndr_print_ptr(ndr, "parameters", r->parameters);
3844         ndr->depth++;
3845         if (r->parameters) {
3846                 ndr_print_string(ndr, "parameters", r->parameters);
3847         }
3848         ndr->depth--;
3849         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3850         ndr->depth++;
3851         if (r->secdesc) {
3852                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3853         }
3854         ndr->depth--;
3855         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
3856         ndr_print_uint32(ndr, "priority", r->priority);
3857         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
3858         ndr_print_uint32(ndr, "starttime", r->starttime);
3859         ndr_print_uint32(ndr, "untiltime", r->untiltime);
3860         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
3861         ndr_print_uint32(ndr, "cjobs", r->cjobs);
3862         ndr_print_uint32(ndr, "averageppm", r->averageppm);
3863         ndr->depth--;
3864 }
3865
3866 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
3867 {
3868         if (ndr_flags & NDR_SCALARS) {
3869                 NDR_CHECK(ndr_push_align(ndr, 4));
3870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
3871         }
3872         if (ndr_flags & NDR_BUFFERS) {
3873                 if (r->secdesc) {
3874                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3875                 }
3876         }
3877         return NDR_ERR_SUCCESS;
3878 }
3879
3880 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
3881 {
3882         uint32_t _ptr_secdesc;
3883         TALLOC_CTX *_mem_save_secdesc_0;
3884         if (ndr_flags & NDR_SCALARS) {
3885                 NDR_CHECK(ndr_pull_align(ndr, 4));
3886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3887                 if (_ptr_secdesc) {
3888                         NDR_PULL_ALLOC(ndr, r->secdesc);
3889                 } else {
3890                         r->secdesc = NULL;
3891                 }
3892         }
3893         if (ndr_flags & NDR_BUFFERS) {
3894                 if (r->secdesc) {
3895                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3896                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3897                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3899                 }
3900         }
3901         return NDR_ERR_SUCCESS;
3902 }
3903
3904 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
3905 {
3906         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
3907         ndr->depth++;
3908         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3909         ndr->depth++;
3910         if (r->secdesc) {
3911                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3912         }
3913         ndr->depth--;
3914         ndr->depth--;
3915 }
3916
3917 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
3918 {
3919         if (ndr_flags & NDR_SCALARS) {
3920                 NDR_CHECK(ndr_push_align(ndr, 4));
3921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
3922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
3923                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
3924         }
3925         if (ndr_flags & NDR_BUFFERS) {
3926                 if (r->printername) {
3927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
3930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3931                 }
3932                 if (r->servername) {
3933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
3936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3937                 }
3938         }
3939         return NDR_ERR_SUCCESS;
3940 }
3941
3942 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
3943 {
3944         uint32_t _ptr_printername;
3945         TALLOC_CTX *_mem_save_printername_0;
3946         uint32_t _ptr_servername;
3947         TALLOC_CTX *_mem_save_servername_0;
3948         if (ndr_flags & NDR_SCALARS) {
3949                 NDR_CHECK(ndr_pull_align(ndr, 4));
3950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
3951                 if (_ptr_printername) {
3952                         NDR_PULL_ALLOC(ndr, r->printername);
3953                 } else {
3954                         r->printername = NULL;
3955                 }
3956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
3957                 if (_ptr_servername) {
3958                         NDR_PULL_ALLOC(ndr, r->servername);
3959                 } else {
3960                         r->servername = NULL;
3961                 }
3962                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
3963         }
3964         if (ndr_flags & NDR_BUFFERS) {
3965                 if (r->printername) {
3966                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3967                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
3968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
3969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
3970                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
3971                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
3972                         }
3973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
3974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
3975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
3976                 }
3977                 if (r->servername) {
3978                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
3979                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
3980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
3981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
3982                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
3983                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
3984                         }
3985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
3986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
3987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
3988                 }
3989         }
3990         return NDR_ERR_SUCCESS;
3991 }
3992
3993 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
3994 {
3995         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
3996         ndr->depth++;
3997         ndr_print_ptr(ndr, "printername", r->printername);
3998         ndr->depth++;
3999         if (r->printername) {
4000                 ndr_print_string(ndr, "printername", r->printername);
4001         }
4002         ndr->depth--;
4003         ndr_print_ptr(ndr, "servername", r->servername);
4004         ndr->depth++;
4005         if (r->servername) {
4006                 ndr_print_string(ndr, "servername", r->servername);
4007         }
4008         ndr->depth--;
4009         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4010         ndr->depth--;
4011 }
4012
4013 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
4014 {
4015         if (ndr_flags & NDR_SCALARS) {
4016                 NDR_CHECK(ndr_push_align(ndr, 4));
4017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
4018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
4019                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
4020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
4021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
4022         }
4023         if (ndr_flags & NDR_BUFFERS) {
4024                 if (r->printername) {
4025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4029                 }
4030                 if (r->portname) {
4031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4035                 }
4036         }
4037         return NDR_ERR_SUCCESS;
4038 }
4039
4040 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
4041 {
4042         uint32_t _ptr_printername;
4043         TALLOC_CTX *_mem_save_printername_0;
4044         uint32_t _ptr_portname;
4045         TALLOC_CTX *_mem_save_portname_0;
4046         if (ndr_flags & NDR_SCALARS) {
4047                 NDR_CHECK(ndr_pull_align(ndr, 4));
4048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
4049                 if (_ptr_printername) {
4050                         NDR_PULL_ALLOC(ndr, r->printername);
4051                 } else {
4052                         r->printername = NULL;
4053                 }
4054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
4055                 if (_ptr_portname) {
4056                         NDR_PULL_ALLOC(ndr, r->portname);
4057                 } else {
4058                         r->portname = NULL;
4059                 }
4060                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
4061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
4062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
4063         }
4064         if (ndr_flags & NDR_BUFFERS) {
4065                 if (r->printername) {
4066                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4067                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
4068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
4069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
4070                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
4071                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
4072                         }
4073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
4074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
4075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
4076                 }
4077                 if (r->portname) {
4078                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
4079                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
4080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
4081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
4082                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
4083                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
4084                         }
4085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
4086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
4087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
4088                 }
4089         }
4090         return NDR_ERR_SUCCESS;
4091 }
4092
4093 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
4094 {
4095         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
4096         ndr->depth++;
4097         ndr_print_ptr(ndr, "printername", r->printername);
4098         ndr->depth++;
4099         if (r->printername) {
4100                 ndr_print_string(ndr, "printername", r->printername);
4101         }
4102         ndr->depth--;
4103         ndr_print_ptr(ndr, "portname", r->portname);
4104         ndr->depth++;
4105         if (r->portname) {
4106                 ndr_print_string(ndr, "portname", r->portname);
4107         }
4108         ndr->depth--;
4109         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
4110         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
4111         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
4112         ndr->depth--;
4113 }
4114
4115 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
4116 {
4117         if (ndr_flags & NDR_SCALARS) {
4118                 NDR_CHECK(ndr_push_align(ndr, 4));
4119                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
4120         }
4121         if (ndr_flags & NDR_BUFFERS) {
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
4127 {
4128         if (ndr_flags & NDR_SCALARS) {
4129                 NDR_CHECK(ndr_pull_align(ndr, 4));
4130                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
4131         }
4132         if (ndr_flags & NDR_BUFFERS) {
4133         }
4134         return NDR_ERR_SUCCESS;
4135 }
4136
4137 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
4138 {
4139         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
4140         ndr->depth++;
4141         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
4142         ndr->depth--;
4143 }
4144
4145 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
4146 {
4147         if (ndr_flags & NDR_SCALARS) {
4148                 NDR_CHECK(ndr_push_align(ndr, 4));
4149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
4150                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
4151         }
4152         if (ndr_flags & NDR_BUFFERS) {
4153                 if (r->guid) {
4154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
4157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4158                 }
4159         }
4160         return NDR_ERR_SUCCESS;
4161 }
4162
4163 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
4164 {
4165         uint32_t _ptr_guid;
4166         TALLOC_CTX *_mem_save_guid_0;
4167         if (ndr_flags & NDR_SCALARS) {
4168                 NDR_CHECK(ndr_pull_align(ndr, 4));
4169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
4170                 if (_ptr_guid) {
4171                         NDR_PULL_ALLOC(ndr, r->guid);
4172                 } else {
4173                         r->guid = NULL;
4174                 }
4175                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
4176         }
4177         if (ndr_flags & NDR_BUFFERS) {
4178                 if (r->guid) {
4179                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4180                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
4181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
4182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
4183                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
4184                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
4185                         }
4186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
4187                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
4188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
4189                 }
4190         }
4191         return NDR_ERR_SUCCESS;
4192 }
4193
4194 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
4195 {
4196         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
4197         ndr->depth++;
4198         ndr_print_ptr(ndr, "guid", r->guid);
4199         ndr->depth++;
4200         if (r->guid) {
4201                 ndr_print_string(ndr, "guid", r->guid);
4202         }
4203         ndr->depth--;
4204         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
4205         ndr->depth--;
4206 }
4207
4208 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
4209 {
4210         if (ndr_flags & NDR_SCALARS) {
4211                 int level = ndr_push_get_switch_value(ndr, r);
4212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4213                 switch (level) {
4214                         case 0: {
4215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
4216                         break; }
4217
4218                         case 1: {
4219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
4220                         break; }
4221
4222                         case 2: {
4223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
4224                         break; }
4225
4226                         case 3: {
4227                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
4228                         break; }
4229
4230                         case 4: {
4231                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
4232                         break; }
4233
4234                         case 5: {
4235                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
4236                         break; }
4237
4238                         case 6: {
4239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
4240                         break; }
4241
4242                         case 7: {
4243                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
4244                         break; }
4245
4246                         case 8: {
4247                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
4248                         break; }
4249
4250                         case 9: {
4251                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
4252                         break; }
4253
4254                         default: {
4255                         break; }
4256
4257                 }
4258         }
4259         if (ndr_flags & NDR_BUFFERS) {
4260                 int level = ndr_push_get_switch_value(ndr, r);
4261                 switch (level) {
4262                         case 0:
4263                                 if (r->info0) {
4264                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4265                                 }
4266                         break;
4267
4268                         case 1:
4269                                 if (r->info1) {
4270                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4271                                 }
4272                         break;
4273
4274                         case 2:
4275                                 if (r->info2) {
4276                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4277                                 }
4278                         break;
4279
4280                         case 3:
4281                                 if (r->info3) {
4282                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4283                                 }
4284                         break;
4285
4286                         case 4:
4287                                 if (r->info4) {
4288                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4289                                 }
4290                         break;
4291
4292                         case 5:
4293                                 if (r->info5) {
4294                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4295                                 }
4296                         break;
4297
4298                         case 6:
4299                                 if (r->info6) {
4300                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4301                                 }
4302                         break;
4303
4304                         case 7:
4305                                 if (r->info7) {
4306                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4307                                 }
4308                         break;
4309
4310                         case 8:
4311                                 if (r->info8) {
4312                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4313                                 }
4314                         break;
4315
4316                         case 9:
4317                                 if (r->info9) {
4318                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4319                                 }
4320                         break;
4321
4322                         default:
4323                         break;
4324
4325                 }
4326         }
4327         return NDR_ERR_SUCCESS;
4328 }
4329
4330 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
4331 {
4332         int level;
4333         uint32_t _level;
4334         TALLOC_CTX *_mem_save_info0_0;
4335         TALLOC_CTX *_mem_save_info1_0;
4336         TALLOC_CTX *_mem_save_info2_0;
4337         TALLOC_CTX *_mem_save_info3_0;
4338         TALLOC_CTX *_mem_save_info4_0;
4339         TALLOC_CTX *_mem_save_info5_0;
4340         TALLOC_CTX *_mem_save_info6_0;
4341         TALLOC_CTX *_mem_save_info7_0;
4342         TALLOC_CTX *_mem_save_info8_0;
4343         TALLOC_CTX *_mem_save_info9_0;
4344         level = ndr_pull_get_switch_value(ndr, r);
4345         if (ndr_flags & NDR_SCALARS) {
4346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4347                 if (_level != level) {
4348                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4349                 }
4350                 switch (level) {
4351                         case 0: {
4352                                 uint32_t _ptr_info0;
4353                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
4354                                 if (_ptr_info0) {
4355                                         NDR_PULL_ALLOC(ndr, r->info0);
4356                                 } else {
4357                                         r->info0 = NULL;
4358                                 }
4359                         break; }
4360
4361                         case 1: {
4362                                 uint32_t _ptr_info1;
4363                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
4364                                 if (_ptr_info1) {
4365                                         NDR_PULL_ALLOC(ndr, r->info1);
4366                                 } else {
4367                                         r->info1 = NULL;
4368                                 }
4369                         break; }
4370
4371                         case 2: {
4372                                 uint32_t _ptr_info2;
4373                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
4374                                 if (_ptr_info2) {
4375                                         NDR_PULL_ALLOC(ndr, r->info2);
4376                                 } else {
4377                                         r->info2 = NULL;
4378                                 }
4379                         break; }
4380
4381                         case 3: {
4382                                 uint32_t _ptr_info3;
4383                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
4384                                 if (_ptr_info3) {
4385                                         NDR_PULL_ALLOC(ndr, r->info3);
4386                                 } else {
4387                                         r->info3 = NULL;
4388                                 }
4389                         break; }
4390
4391                         case 4: {
4392                                 uint32_t _ptr_info4;
4393                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
4394                                 if (_ptr_info4) {
4395                                         NDR_PULL_ALLOC(ndr, r->info4);
4396                                 } else {
4397                                         r->info4 = NULL;
4398                                 }
4399                         break; }
4400
4401                         case 5: {
4402                                 uint32_t _ptr_info5;
4403                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
4404                                 if (_ptr_info5) {
4405                                         NDR_PULL_ALLOC(ndr, r->info5);
4406                                 } else {
4407                                         r->info5 = NULL;
4408                                 }
4409                         break; }
4410
4411                         case 6: {
4412                                 uint32_t _ptr_info6;
4413                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
4414                                 if (_ptr_info6) {
4415                                         NDR_PULL_ALLOC(ndr, r->info6);
4416                                 } else {
4417                                         r->info6 = NULL;
4418                                 }
4419                         break; }
4420
4421                         case 7: {
4422                                 uint32_t _ptr_info7;
4423                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
4424                                 if (_ptr_info7) {
4425                                         NDR_PULL_ALLOC(ndr, r->info7);
4426                                 } else {
4427                                         r->info7 = NULL;
4428                                 }
4429                         break; }
4430
4431                         case 8: {
4432                                 uint32_t _ptr_info8;
4433                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
4434                                 if (_ptr_info8) {
4435                                         NDR_PULL_ALLOC(ndr, r->info8);
4436                                 } else {
4437                                         r->info8 = NULL;
4438                                 }
4439                         break; }
4440
4441                         case 9: {
4442                                 uint32_t _ptr_info9;
4443                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
4444                                 if (_ptr_info9) {
4445                                         NDR_PULL_ALLOC(ndr, r->info9);
4446                                 } else {
4447                                         r->info9 = NULL;
4448                                 }
4449                         break; }
4450
4451                         default: {
4452                         break; }
4453
4454                 }
4455         }
4456         if (ndr_flags & NDR_BUFFERS) {
4457                 switch (level) {
4458                         case 0:
4459                                 if (r->info0) {
4460                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
4461                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
4462                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
4463                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
4464                                 }
4465                         break;
4466
4467                         case 1:
4468                                 if (r->info1) {
4469                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
4470                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
4471                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
4472                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
4473                                 }
4474                         break;
4475
4476                         case 2:
4477                                 if (r->info2) {
4478                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
4479                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
4480                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
4481                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
4482                                 }
4483                         break;
4484
4485                         case 3:
4486                                 if (r->info3) {
4487                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
4488                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
4489                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
4490                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
4491                                 }
4492                         break;
4493
4494                         case 4:
4495                                 if (r->info4) {
4496                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
4497                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
4498                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
4499                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
4500                                 }
4501                         break;
4502
4503                         case 5:
4504                                 if (r->info5) {
4505                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
4506                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
4507                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
4508                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
4509                                 }
4510                         break;
4511
4512                         case 6:
4513                                 if (r->info6) {
4514                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
4515                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
4516                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
4517                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
4518                                 }
4519                         break;
4520
4521                         case 7:
4522                                 if (r->info7) {
4523                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
4524                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
4525                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
4526                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
4527                                 }
4528                         break;
4529
4530                         case 8:
4531                                 if (r->info8) {
4532                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
4533                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
4534                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
4535                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
4536                                 }
4537                         break;
4538
4539                         case 9:
4540                                 if (r->info9) {
4541                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
4542                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
4543                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
4544                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
4545                                 }
4546                         break;
4547
4548                         default:
4549                         break;
4550
4551                 }
4552         }
4553         return NDR_ERR_SUCCESS;
4554 }
4555
4556 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
4557 {
4558         int level;
4559         level = ndr_print_get_switch_value(ndr, r);
4560         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
4561         switch (level) {
4562                 case 0:
4563                         ndr_print_ptr(ndr, "info0", r->info0);
4564                         ndr->depth++;
4565                         if (r->info0) {
4566                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
4567                         }
4568                         ndr->depth--;
4569                 break;
4570
4571                 case 1:
4572                         ndr_print_ptr(ndr, "info1", r->info1);
4573                         ndr->depth++;
4574                         if (r->info1) {
4575                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
4576                         }
4577                         ndr->depth--;
4578                 break;
4579
4580                 case 2:
4581                         ndr_print_ptr(ndr, "info2", r->info2);
4582                         ndr->depth++;
4583                         if (r->info2) {
4584                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
4585                         }
4586                         ndr->depth--;
4587                 break;
4588
4589                 case 3:
4590                         ndr_print_ptr(ndr, "info3", r->info3);
4591                         ndr->depth++;
4592                         if (r->info3) {
4593                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
4594                         }
4595                         ndr->depth--;
4596                 break;
4597
4598                 case 4:
4599                         ndr_print_ptr(ndr, "info4", r->info4);
4600                         ndr->depth++;
4601                         if (r->info4) {
4602                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
4603                         }
4604                         ndr->depth--;
4605                 break;
4606
4607                 case 5:
4608                         ndr_print_ptr(ndr, "info5", r->info5);
4609                         ndr->depth++;
4610                         if (r->info5) {
4611                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
4612                         }
4613                         ndr->depth--;
4614                 break;
4615
4616                 case 6:
4617                         ndr_print_ptr(ndr, "info6", r->info6);
4618                         ndr->depth++;
4619                         if (r->info6) {
4620                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
4621                         }
4622                         ndr->depth--;
4623                 break;
4624
4625                 case 7:
4626                         ndr_print_ptr(ndr, "info7", r->info7);
4627                         ndr->depth++;
4628                         if (r->info7) {
4629                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
4630                         }
4631                         ndr->depth--;
4632                 break;
4633
4634                 case 8:
4635                         ndr_print_ptr(ndr, "info8", r->info8);
4636                         ndr->depth++;
4637                         if (r->info8) {
4638                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
4639                         }
4640                         ndr->depth--;
4641                 break;
4642
4643                 case 9:
4644                         ndr_print_ptr(ndr, "info9", r->info9);
4645                         ndr->depth++;
4646                         if (r->info9) {
4647                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
4648                         }
4649                         ndr->depth--;
4650                 break;
4651
4652                 default:
4653                 break;
4654
4655         }
4656 }
4657
4658 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
4659 {
4660         if (ndr_flags & NDR_SCALARS) {
4661                 NDR_CHECK(ndr_push_align(ndr, 4));
4662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
4664                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4665         }
4666         if (ndr_flags & NDR_BUFFERS) {
4667                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4668         }
4669         return NDR_ERR_SUCCESS;
4670 }
4671
4672 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
4673 {
4674         if (ndr_flags & NDR_SCALARS) {
4675                 NDR_CHECK(ndr_pull_align(ndr, 4));
4676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4677                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
4678                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
4679         }
4680         if (ndr_flags & NDR_BUFFERS) {
4681                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
4682         }
4683         return NDR_ERR_SUCCESS;
4684 }
4685
4686 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
4687 {
4688         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
4689         ndr->depth++;
4690         ndr_print_uint32(ndr, "level", r->level);
4691         ndr_print_set_switch_value(ndr, &r->info, r->level);
4692         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
4693         ndr->depth--;
4694 }
4695
4696 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
4697 {
4698         if (ndr_flags & NDR_SCALARS) {
4699                 NDR_CHECK(ndr_push_align(ndr, 4));
4700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
4701                 {
4702                         uint32_t _flags_save_string_array = ndr->flags;
4703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4704                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
4705                         ndr->flags = _flags_save_string_array;
4706                 }
4707         }
4708         if (ndr_flags & NDR_BUFFERS) {
4709         }
4710         return NDR_ERR_SUCCESS;
4711 }
4712
4713 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
4714 {
4715         if (ndr_flags & NDR_SCALARS) {
4716                 NDR_CHECK(ndr_pull_align(ndr, 4));
4717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
4718                 {
4719                         uint32_t _flags_save_string_array = ndr->flags;
4720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4721                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
4722                         ndr->flags = _flags_save_string_array;
4723                 }
4724         }
4725         if (ndr_flags & NDR_BUFFERS) {
4726         }
4727         return NDR_ERR_SUCCESS;
4728 }
4729
4730 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
4731 {
4732         ndr_print_struct(ndr, name, "spoolss_StringArray");
4733         ndr->depth++;
4734         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);
4735         ndr_print_string_array(ndr, "string", r->string);
4736         ndr->depth--;
4737 }
4738
4739 _PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
4740 {
4741         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
4742 }
4743
4744 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
4745 {
4746         if (ndr_flags & NDR_SCALARS) {
4747                 NDR_CHECK(ndr_push_align(ndr, 4));
4748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4749         }
4750         if (ndr_flags & NDR_BUFFERS) {
4751                 if (r->driver_name) {
4752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4756                 }
4757         }
4758         return NDR_ERR_SUCCESS;
4759 }
4760
4761 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
4762 {
4763         uint32_t _ptr_driver_name;
4764         TALLOC_CTX *_mem_save_driver_name_0;
4765         if (ndr_flags & NDR_SCALARS) {
4766                 NDR_CHECK(ndr_pull_align(ndr, 4));
4767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4768                 if (_ptr_driver_name) {
4769                         NDR_PULL_ALLOC(ndr, r->driver_name);
4770                 } else {
4771                         r->driver_name = NULL;
4772                 }
4773         }
4774         if (ndr_flags & NDR_BUFFERS) {
4775                 if (r->driver_name) {
4776                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4777                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4780                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4781                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4782                         }
4783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4786                 }
4787         }
4788         return NDR_ERR_SUCCESS;
4789 }
4790
4791 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
4792 {
4793         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
4794         ndr->depth++;
4795         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4796         ndr->depth++;
4797         if (r->driver_name) {
4798                 ndr_print_string(ndr, "driver_name", r->driver_name);
4799         }
4800         ndr->depth--;
4801         ndr->depth--;
4802 }
4803
4804 static enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
4805 {
4806         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4807         return NDR_ERR_SUCCESS;
4808 }
4809
4810 static enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
4811 {
4812         uint32_t v;
4813         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4814         *r = v;
4815         return NDR_ERR_SUCCESS;
4816 }
4817
4818 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
4819 {
4820         const char *val = NULL;
4821
4822         switch (r) {
4823                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
4824                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
4825                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
4826                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
4827         }
4828         ndr_print_enum(ndr, name, "ENUM", val, r);
4829 }
4830
4831 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
4832 {
4833         if (ndr_flags & NDR_SCALARS) {
4834                 NDR_CHECK(ndr_push_align(ndr, 4));
4835                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
4836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4837                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
4838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
4839                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
4840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
4841         }
4842         if (ndr_flags & NDR_BUFFERS) {
4843                 if (r->driver_name) {
4844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4848                 }
4849                 if (r->architecture) {
4850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
4853                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4854                 }
4855                 if (r->driver_path) {
4856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
4859                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4860                 }
4861                 if (r->data_file) {
4862                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
4865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4866                 }
4867                 if (r->config_file) {
4868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
4871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4872                 }
4873         }
4874         return NDR_ERR_SUCCESS;
4875 }
4876
4877 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
4878 {
4879         uint32_t _ptr_driver_name;
4880         TALLOC_CTX *_mem_save_driver_name_0;
4881         uint32_t _ptr_architecture;
4882         TALLOC_CTX *_mem_save_architecture_0;
4883         uint32_t _ptr_driver_path;
4884         TALLOC_CTX *_mem_save_driver_path_0;
4885         uint32_t _ptr_data_file;
4886         TALLOC_CTX *_mem_save_data_file_0;
4887         uint32_t _ptr_config_file;
4888         TALLOC_CTX *_mem_save_config_file_0;
4889         if (ndr_flags & NDR_SCALARS) {
4890                 NDR_CHECK(ndr_pull_align(ndr, 4));
4891                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
4892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4893                 if (_ptr_driver_name) {
4894                         NDR_PULL_ALLOC(ndr, r->driver_name);
4895                 } else {
4896                         r->driver_name = NULL;
4897                 }
4898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
4899                 if (_ptr_architecture) {
4900                         NDR_PULL_ALLOC(ndr, r->architecture);
4901                 } else {
4902                         r->architecture = NULL;
4903                 }
4904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
4905                 if (_ptr_driver_path) {
4906                         NDR_PULL_ALLOC(ndr, r->driver_path);
4907                 } else {
4908                         r->driver_path = NULL;
4909                 }
4910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
4911                 if (_ptr_data_file) {
4912                         NDR_PULL_ALLOC(ndr, r->data_file);
4913                 } else {
4914                         r->data_file = NULL;
4915                 }
4916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
4917                 if (_ptr_config_file) {
4918                         NDR_PULL_ALLOC(ndr, r->config_file);
4919                 } else {
4920                         r->config_file = NULL;
4921                 }
4922         }
4923         if (ndr_flags & NDR_BUFFERS) {
4924                 if (r->driver_name) {
4925                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4926                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4929                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4930                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4931                         }
4932                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4933                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4935                 }
4936                 if (r->architecture) {
4937                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4938                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
4940                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
4941                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
4942                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
4943                         }
4944                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
4945                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
4946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4947                 }
4948                 if (r->driver_path) {
4949                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4950                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4951                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
4952                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
4953                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
4954                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
4955                         }
4956                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
4957                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
4958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4959                 }
4960                 if (r->data_file) {
4961                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4962                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
4964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
4965                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
4966                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
4967                         }
4968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
4969                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
4970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4971                 }
4972                 if (r->config_file) {
4973                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4974                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
4976                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
4977                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
4978                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
4979                         }
4980                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
4981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
4982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4983                 }
4984         }
4985         return NDR_ERR_SUCCESS;
4986 }
4987
4988 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
4989 {
4990         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
4991         ndr->depth++;
4992         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4993         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4994         ndr->depth++;
4995         if (r->driver_name) {
4996                 ndr_print_string(ndr, "driver_name", r->driver_name);
4997         }
4998         ndr->depth--;
4999         ndr_print_ptr(ndr, "architecture", r->architecture);
5000         ndr->depth++;
5001         if (r->architecture) {
5002                 ndr_print_string(ndr, "architecture", r->architecture);
5003         }
5004         ndr->depth--;
5005         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5006         ndr->depth++;
5007         if (r->driver_path) {
5008                 ndr_print_string(ndr, "driver_path", r->driver_path);
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "data_file", r->data_file);
5012         ndr->depth++;
5013         if (r->data_file) {
5014                 ndr_print_string(ndr, "data_file", r->data_file);
5015         }
5016         ndr->depth--;
5017         ndr_print_ptr(ndr, "config_file", r->config_file);
5018         ndr->depth++;
5019         if (r->config_file) {
5020                 ndr_print_string(ndr, "config_file", r->config_file);
5021         }
5022         ndr->depth--;
5023         ndr->depth--;
5024 }
5025
5026 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
5027 {
5028         if (ndr_flags & NDR_SCALARS) {
5029                 NDR_CHECK(ndr_push_align(ndr, 4));
5030                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5041         }
5042         if (ndr_flags & NDR_BUFFERS) {
5043                 if (r->driver_name) {
5044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5047                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5048                 }
5049                 if (r->architecture) {
5050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5054                 }
5055                 if (r->driver_path) {
5056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5059                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5060                 }
5061                 if (r->data_file) {
5062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5066                 }
5067                 if (r->config_file) {
5068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5071                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5072                 }
5073                 if (r->help_file) {
5074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5078                 }
5079                 if (r->monitor_name) {
5080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5084                 }
5085                 if (r->default_datatype) {
5086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5090                 }
5091                 if (r->dependent_files) {
5092                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5093                 }
5094         }
5095         return NDR_ERR_SUCCESS;
5096 }
5097
5098 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
5099 {
5100         uint32_t _ptr_driver_name;
5101         TALLOC_CTX *_mem_save_driver_name_0;
5102         uint32_t _ptr_architecture;
5103         TALLOC_CTX *_mem_save_architecture_0;
5104         uint32_t _ptr_driver_path;
5105         TALLOC_CTX *_mem_save_driver_path_0;
5106         uint32_t _ptr_data_file;
5107         TALLOC_CTX *_mem_save_data_file_0;
5108         uint32_t _ptr_config_file;
5109         TALLOC_CTX *_mem_save_config_file_0;
5110         uint32_t _ptr_help_file;
5111         TALLOC_CTX *_mem_save_help_file_0;
5112         uint32_t _ptr_monitor_name;
5113         TALLOC_CTX *_mem_save_monitor_name_0;
5114         uint32_t _ptr_default_datatype;
5115         TALLOC_CTX *_mem_save_default_datatype_0;
5116         uint32_t _ptr_dependent_files;
5117         TALLOC_CTX *_mem_save_dependent_files_0;
5118         if (ndr_flags & NDR_SCALARS) {
5119                 NDR_CHECK(ndr_pull_align(ndr, 4));
5120                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5122                 if (_ptr_driver_name) {
5123                         NDR_PULL_ALLOC(ndr, r->driver_name);
5124                 } else {
5125                         r->driver_name = NULL;
5126                 }
5127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5128                 if (_ptr_architecture) {
5129                         NDR_PULL_ALLOC(ndr, r->architecture);
5130                 } else {
5131                         r->architecture = NULL;
5132                 }
5133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5134                 if (_ptr_driver_path) {
5135                         NDR_PULL_ALLOC(ndr, r->driver_path);
5136                 } else {
5137                         r->driver_path = NULL;
5138                 }
5139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5140                 if (_ptr_data_file) {
5141                         NDR_PULL_ALLOC(ndr, r->data_file);
5142                 } else {
5143                         r->data_file = NULL;
5144                 }
5145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5146                 if (_ptr_config_file) {
5147                         NDR_PULL_ALLOC(ndr, r->config_file);
5148                 } else {
5149                         r->config_file = NULL;
5150                 }
5151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5152                 if (_ptr_help_file) {
5153                         NDR_PULL_ALLOC(ndr, r->help_file);
5154                 } else {
5155                         r->help_file = NULL;
5156                 }
5157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5158                 if (_ptr_monitor_name) {
5159                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5160                 } else {
5161                         r->monitor_name = NULL;
5162                 }
5163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5164                 if (_ptr_default_datatype) {
5165                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5166                 } else {
5167                         r->default_datatype = NULL;
5168                 }
5169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5171                 if (_ptr_dependent_files) {
5172                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5173                 } else {
5174                         r->dependent_files = NULL;
5175                 }
5176         }
5177         if (ndr_flags & NDR_BUFFERS) {
5178                 if (r->driver_name) {
5179                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5180                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5182                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5183                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5184                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5185                         }
5186                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5187                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5189                 }
5190                 if (r->architecture) {
5191                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5192                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5194                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5195                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5196                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5197                         }
5198                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5199                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5201                 }
5202                 if (r->driver_path) {
5203                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5204                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5205                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5206                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5207                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5208                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5209                         }
5210                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5211                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5213                 }
5214                 if (r->data_file) {
5215                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5216                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5217                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5218                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5219                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5220                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5221                         }
5222                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5223                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5225                 }
5226                 if (r->config_file) {
5227                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5228                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5229                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5230                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5231                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5232                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5233                         }
5234                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5235                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5236                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5237                 }
5238                 if (r->help_file) {
5239                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5240                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5241                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5242                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5243                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5244                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5245                         }
5246                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5247                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5249                 }
5250                 if (r->monitor_name) {
5251                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5252                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5255                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5256                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5257                         }
5258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5261                 }
5262                 if (r->default_datatype) {
5263                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5264                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5266                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5267                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5268                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
5269                         }
5270                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5271                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5273                 }
5274                 if (r->dependent_files) {
5275                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5276                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5277                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5279                 }
5280         }
5281         return NDR_ERR_SUCCESS;
5282 }
5283
5284 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
5285 {
5286         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
5287         ndr->depth++;
5288         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5289         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5290         ndr->depth++;
5291         if (r->driver_name) {
5292                 ndr_print_string(ndr, "driver_name", r->driver_name);
5293         }
5294         ndr->depth--;
5295         ndr_print_ptr(ndr, "architecture", r->architecture);
5296         ndr->depth++;
5297         if (r->architecture) {
5298                 ndr_print_string(ndr, "architecture", r->architecture);
5299         }
5300         ndr->depth--;
5301         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5302         ndr->depth++;
5303         if (r->driver_path) {
5304                 ndr_print_string(ndr, "driver_path", r->driver_path);
5305         }
5306         ndr->depth--;
5307         ndr_print_ptr(ndr, "data_file", r->data_file);
5308         ndr->depth++;
5309         if (r->data_file) {
5310                 ndr_print_string(ndr, "data_file", r->data_file);
5311         }
5312         ndr->depth--;
5313         ndr_print_ptr(ndr, "config_file", r->config_file);
5314         ndr->depth++;
5315         if (r->config_file) {
5316                 ndr_print_string(ndr, "config_file", r->config_file);
5317         }
5318         ndr->depth--;
5319         ndr_print_ptr(ndr, "help_file", r->help_file);
5320         ndr->depth++;
5321         if (r->help_file) {
5322                 ndr_print_string(ndr, "help_file", r->help_file);
5323         }
5324         ndr->depth--;
5325         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5326         ndr->depth++;
5327         if (r->monitor_name) {
5328                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5329         }
5330         ndr->depth--;
5331         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5332         ndr->depth++;
5333         if (r->default_datatype) {
5334                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5335         }
5336         ndr->depth--;
5337         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);
5338         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5339         ndr->depth++;
5340         if (r->dependent_files) {
5341                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5342         }
5343         ndr->depth--;
5344         ndr->depth--;
5345 }
5346
5347 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
5348 {
5349         if (ndr_flags & NDR_SCALARS) {
5350                 NDR_CHECK(ndr_push_align(ndr, 4));
5351                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5364         }
5365         if (ndr_flags & NDR_BUFFERS) {
5366                 if (r->driver_name) {
5367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5371                 }
5372                 if (r->architecture) {
5373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5377                 }
5378                 if (r->driver_path) {
5379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5383                 }
5384                 if (r->data_file) {
5385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5388                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5389                 }
5390                 if (r->config_file) {
5391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5395                 }
5396                 if (r->help_file) {
5397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5401                 }
5402                 if (r->monitor_name) {
5403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5407                 }
5408                 if (r->default_datatype) {
5409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5413                 }
5414                 if (r->dependent_files) {
5415                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5416                 }
5417                 if (r->previous_names) {
5418                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5419                 }
5420         }
5421         return NDR_ERR_SUCCESS;
5422 }
5423
5424 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
5425 {
5426         uint32_t _ptr_driver_name;
5427         TALLOC_CTX *_mem_save_driver_name_0;
5428         uint32_t _ptr_architecture;
5429         TALLOC_CTX *_mem_save_architecture_0;
5430         uint32_t _ptr_driver_path;
5431         TALLOC_CTX *_mem_save_driver_path_0;
5432         uint32_t _ptr_data_file;
5433         TALLOC_CTX *_mem_save_data_file_0;
5434         uint32_t _ptr_config_file;
5435         TALLOC_CTX *_mem_save_config_file_0;
5436         uint32_t _ptr_help_file;
5437         TALLOC_CTX *_mem_save_help_file_0;
5438         uint32_t _ptr_monitor_name;
5439         TALLOC_CTX *_mem_save_monitor_name_0;
5440         uint32_t _ptr_default_datatype;
5441         TALLOC_CTX *_mem_save_default_datatype_0;
5442         uint32_t _ptr_dependent_files;
5443         TALLOC_CTX *_mem_save_dependent_files_0;
5444         uint32_t _ptr_previous_names;
5445         TALLOC_CTX *_mem_save_previous_names_0;
5446         if (ndr_flags & NDR_SCALARS) {
5447                 NDR_CHECK(ndr_pull_align(ndr, 4));
5448                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5449                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5450                 if (_ptr_driver_name) {
5451                         NDR_PULL_ALLOC(ndr, r->driver_name);
5452                 } else {
5453                         r->driver_name = NULL;
5454                 }
5455                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5456                 if (_ptr_architecture) {
5457                         NDR_PULL_ALLOC(ndr, r->architecture);
5458                 } else {
5459                         r->architecture = NULL;
5460                 }
5461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5462                 if (_ptr_driver_path) {
5463                         NDR_PULL_ALLOC(ndr, r->driver_path);
5464                 } else {
5465                         r->driver_path = NULL;
5466                 }
5467                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5468                 if (_ptr_data_file) {
5469                         NDR_PULL_ALLOC(ndr, r->data_file);
5470                 } else {
5471                         r->data_file = NULL;
5472                 }
5473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5474                 if (_ptr_config_file) {
5475                         NDR_PULL_ALLOC(ndr, r->config_file);
5476                 } else {
5477                         r->config_file = NULL;
5478                 }
5479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5480                 if (_ptr_help_file) {
5481                         NDR_PULL_ALLOC(ndr, r->help_file);
5482                 } else {
5483                         r->help_file = NULL;
5484                 }
5485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5486                 if (_ptr_monitor_name) {
5487                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5488                 } else {
5489                         r->monitor_name = NULL;
5490                 }
5491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5492                 if (_ptr_default_datatype) {
5493                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5494                 } else {
5495                         r->default_datatype = NULL;
5496                 }
5497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5499                 if (_ptr_dependent_files) {
5500                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5501                 } else {
5502                         r->dependent_files = NULL;
5503                 }
5504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5506                 if (_ptr_previous_names) {
5507                         NDR_PULL_ALLOC(ndr, r->previous_names);
5508                 } else {
5509                         r->previous_names = NULL;
5510                 }
5511         }
5512         if (ndr_flags & NDR_BUFFERS) {
5513                 if (r->driver_name) {
5514                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5515                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5516                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5517                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5518                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5519                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5520                         }
5521                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5522                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5524                 }
5525                 if (r->architecture) {
5526                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5527                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5530                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5531                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5532                         }
5533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5536                 }
5537                 if (r->driver_path) {
5538                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5539                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5542                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5543                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5544                         }
5545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5548                 }
5549                 if (r->data_file) {
5550                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5551                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5554                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5555                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5556                         }
5557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5560                 }
5561                 if (r->config_file) {
5562                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5563                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5566                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5568                         }
5569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5572                 }
5573                 if (r->help_file) {
5574                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5575                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5576                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5577                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5578                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5579                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5580                         }
5581                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5582                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5584                 }
5585                 if (r->monitor_name) {
5586                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5587                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5588                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
5589                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
5590                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
5591                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
5592                         }
5593                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
5594                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
5595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5596                 }
5597                 if (r->default_datatype) {
5598                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5599                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5600                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
5601                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
5602                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
5603                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
5604                         }
5605                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
5606                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
5607                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5608                 }
5609                 if (r->dependent_files) {
5610                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5611                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5612                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5614                 }
5615                 if (r->previous_names) {
5616                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5617                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
5618                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
5620                 }
5621         }
5622         return NDR_ERR_SUCCESS;
5623 }
5624
5625 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
5626 {
5627         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
5628         ndr->depth++;
5629         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5630         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5631         ndr->depth++;
5632         if (r->driver_name) {
5633                 ndr_print_string(ndr, "driver_name", r->driver_name);
5634         }
5635         ndr->depth--;
5636         ndr_print_ptr(ndr, "architecture", r->architecture);
5637         ndr->depth++;
5638         if (r->architecture) {
5639                 ndr_print_string(ndr, "architecture", r->architecture);
5640         }
5641         ndr->depth--;
5642         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5643         ndr->depth++;
5644         if (r->driver_path) {
5645                 ndr_print_string(ndr, "driver_path", r->driver_path);
5646         }
5647         ndr->depth--;
5648         ndr_print_ptr(ndr, "data_file", r->data_file);
5649         ndr->depth++;
5650         if (r->data_file) {
5651                 ndr_print_string(ndr, "data_file", r->data_file);
5652         }
5653         ndr->depth--;
5654         ndr_print_ptr(ndr, "config_file", r->config_file);
5655         ndr->depth++;
5656         if (r->config_file) {
5657                 ndr_print_string(ndr, "config_file", r->config_file);
5658         }
5659         ndr->depth--;
5660         ndr_print_ptr(ndr, "help_file", r->help_file);
5661         ndr->depth++;
5662         if (r->help_file) {
5663                 ndr_print_string(ndr, "help_file", r->help_file);
5664         }
5665         ndr->depth--;
5666         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5667         ndr->depth++;
5668         if (r->monitor_name) {
5669                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5670         }
5671         ndr->depth--;
5672         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5673         ndr->depth++;
5674         if (r->default_datatype) {
5675                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5676         }
5677         ndr->depth--;
5678         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);
5679         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5680         ndr->depth++;
5681         if (r->dependent_files) {
5682                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
5683         }
5684         ndr->depth--;
5685         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);
5686         ndr_print_ptr(ndr, "previous_names", r->previous_names);
5687         ndr->depth++;
5688         if (r->previous_names) {
5689                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
5690         }
5691         ndr->depth--;
5692         ndr->depth--;
5693 }
5694
5695 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
5696 {
5697         if (ndr_flags & NDR_SCALARS) {
5698                 NDR_CHECK(ndr_push_align(ndr, 8));
5699                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
5702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
5703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
5704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
5705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
5706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
5707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
5708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
5710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
5711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
5712                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
5713                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
5714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
5715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
5716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
5717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
5718         }
5719         if (ndr_flags & NDR_BUFFERS) {
5720                 if (r->driver_name) {
5721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5725                 }
5726                 if (r->architecture) {
5727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
5730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5731                 }
5732                 if (r->driver_path) {
5733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
5736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5737                 }
5738                 if (r->data_file) {
5739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
5742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5743                 }
5744                 if (r->config_file) {
5745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
5748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5749                 }
5750                 if (r->help_file) {
5751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
5754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5755                 }
5756                 if (r->monitor_name) {
5757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
5760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5761                 }
5762                 if (r->default_datatype) {
5763                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
5766                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5767                 }
5768                 if (r->dependent_files) {
5769                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
5770                 }
5771                 if (r->previous_names) {
5772                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
5773                 }
5774                 if (r->manufacturer_name) {
5775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
5778                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5779                 }
5780                 if (r->manufacturer_url) {
5781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5782                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
5784                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5785                 }
5786                 if (r->hardware_id) {
5787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
5790                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5791                 }
5792                 if (r->provider) {
5793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5795                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
5796                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5797                 }
5798         }
5799         return NDR_ERR_SUCCESS;
5800 }
5801
5802 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
5803 {
5804         uint32_t _ptr_driver_name;
5805         TALLOC_CTX *_mem_save_driver_name_0;
5806         uint32_t _ptr_architecture;
5807         TALLOC_CTX *_mem_save_architecture_0;
5808         uint32_t _ptr_driver_path;
5809         TALLOC_CTX *_mem_save_driver_path_0;
5810         uint32_t _ptr_data_file;
5811         TALLOC_CTX *_mem_save_data_file_0;
5812         uint32_t _ptr_config_file;
5813         TALLOC_CTX *_mem_save_config_file_0;
5814         uint32_t _ptr_help_file;
5815         TALLOC_CTX *_mem_save_help_file_0;
5816         uint32_t _ptr_monitor_name;
5817         TALLOC_CTX *_mem_save_monitor_name_0;
5818         uint32_t _ptr_default_datatype;
5819         TALLOC_CTX *_mem_save_default_datatype_0;
5820         uint32_t _ptr_dependent_files;
5821         TALLOC_CTX *_mem_save_dependent_files_0;
5822         uint32_t _ptr_previous_names;
5823         TALLOC_CTX *_mem_save_previous_names_0;
5824         uint32_t _ptr_manufacturer_name;
5825         TALLOC_CTX *_mem_save_manufacturer_name_0;
5826         uint32_t _ptr_manufacturer_url;
5827         TALLOC_CTX *_mem_save_manufacturer_url_0;
5828         uint32_t _ptr_hardware_id;
5829         TALLOC_CTX *_mem_save_hardware_id_0;
5830         uint32_t _ptr_provider;
5831         TALLOC_CTX *_mem_save_provider_0;
5832         if (ndr_flags & NDR_SCALARS) {
5833                 NDR_CHECK(ndr_pull_align(ndr, 8));
5834                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5836                 if (_ptr_driver_name) {
5837                         NDR_PULL_ALLOC(ndr, r->driver_name);
5838                 } else {
5839                         r->driver_name = NULL;
5840                 }
5841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5842                 if (_ptr_architecture) {
5843                         NDR_PULL_ALLOC(ndr, r->architecture);
5844                 } else {
5845                         r->architecture = NULL;
5846                 }
5847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5848                 if (_ptr_driver_path) {
5849                         NDR_PULL_ALLOC(ndr, r->driver_path);
5850                 } else {
5851                         r->driver_path = NULL;
5852                 }
5853                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5854                 if (_ptr_data_file) {
5855                         NDR_PULL_ALLOC(ndr, r->data_file);
5856                 } else {
5857                         r->data_file = NULL;
5858                 }
5859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5860                 if (_ptr_config_file) {
5861                         NDR_PULL_ALLOC(ndr, r->config_file);
5862                 } else {
5863                         r->config_file = NULL;
5864                 }
5865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5866                 if (_ptr_help_file) {
5867                         NDR_PULL_ALLOC(ndr, r->help_file);
5868                 } else {
5869                         r->help_file = NULL;
5870                 }
5871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5872                 if (_ptr_monitor_name) {
5873                         NDR_PULL_ALLOC(ndr, r->monitor_name);
5874                 } else {
5875                         r->monitor_name = NULL;
5876                 }
5877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5878                 if (_ptr_default_datatype) {
5879                         NDR_PULL_ALLOC(ndr, r->default_datatype);
5880                 } else {
5881                         r->default_datatype = NULL;
5882                 }
5883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
5884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5885                 if (_ptr_dependent_files) {
5886                         NDR_PULL_ALLOC(ndr, r->dependent_files);
5887                 } else {
5888                         r->dependent_files = NULL;
5889                 }
5890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
5891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5892                 if (_ptr_previous_names) {
5893                         NDR_PULL_ALLOC(ndr, r->previous_names);
5894                 } else {
5895                         r->previous_names = NULL;
5896                 }
5897                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
5898                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
5899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
5900                 if (_ptr_manufacturer_name) {
5901                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
5902                 } else {
5903                         r->manufacturer_name = NULL;
5904                 }
5905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
5906                 if (_ptr_manufacturer_url) {
5907                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
5908                 } else {
5909                         r->manufacturer_url = NULL;
5910                 }
5911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
5912                 if (_ptr_hardware_id) {
5913                         NDR_PULL_ALLOC(ndr, r->hardware_id);
5914                 } else {
5915                         r->hardware_id = NULL;
5916                 }
5917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
5918                 if (_ptr_provider) {
5919                         NDR_PULL_ALLOC(ndr, r->provider);
5920                 } else {
5921                         r->provider = NULL;
5922                 }
5923         }
5924         if (ndr_flags & NDR_BUFFERS) {
5925                 if (r->driver_name) {
5926                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5927                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5930                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5931                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5932                         }
5933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5936                 }
5937                 if (r->architecture) {
5938                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5939                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
5941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
5942                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
5943                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
5944                         }
5945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
5946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
5947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5948                 }
5949                 if (r->driver_path) {
5950                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5951                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
5953                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
5954                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
5955                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
5956                         }
5957                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
5958                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
5959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5960                 }
5961                 if (r->data_file) {
5962                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5963                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5964                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
5965                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
5966                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
5967                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
5968                         }
5969                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
5970                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
5971                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5972                 }
5973                 if (r->config_file) {
5974                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5975                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5976                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
5977                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
5978                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
5979                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
5980                         }
5981                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
5982                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
5983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5984                 }
5985                 if (r->help_file) {
5986                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5987                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5988                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
5989                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
5990                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
5991                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
5992                         }
5993                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
5994                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
5995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5996                 }
5997                 if (r->monitor_name) {
5998                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5999                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6002                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6003                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
6004                         }
6005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6008                 }
6009                 if (r->default_datatype) {
6010                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6011                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6014                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6015                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
6016                         }
6017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6020                 }
6021                 if (r->dependent_files) {
6022                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6023                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6024                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6026                 }
6027                 if (r->previous_names) {
6028                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6030                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6032                 }
6033                 if (r->manufacturer_name) {
6034                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6035                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6038                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6039                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
6040                         }
6041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6044                 }
6045                 if (r->manufacturer_url) {
6046                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6047                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6050                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6051                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
6052                         }
6053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6056                 }
6057                 if (r->hardware_id) {
6058                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6059                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6062                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
6064                         }
6065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6068                 }
6069                 if (r->provider) {
6070                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6071                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6074                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6075                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
6076                         }
6077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6080                 }
6081         }
6082         return NDR_ERR_SUCCESS;
6083 }
6084
6085 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
6086 {
6087         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
6088         ndr->depth++;
6089         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6090         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6091         ndr->depth++;
6092         if (r->driver_name) {
6093                 ndr_print_string(ndr, "driver_name", r->driver_name);
6094         }
6095         ndr->depth--;
6096         ndr_print_ptr(ndr, "architecture", r->architecture);
6097         ndr->depth++;
6098         if (r->architecture) {
6099                 ndr_print_string(ndr, "architecture", r->architecture);
6100         }
6101         ndr->depth--;
6102         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6103         ndr->depth++;
6104         if (r->driver_path) {
6105                 ndr_print_string(ndr, "driver_path", r->driver_path);
6106         }
6107         ndr->depth--;
6108         ndr_print_ptr(ndr, "data_file", r->data_file);
6109         ndr->depth++;
6110         if (r->data_file) {
6111                 ndr_print_string(ndr, "data_file", r->data_file);
6112         }
6113         ndr->depth--;
6114         ndr_print_ptr(ndr, "config_file", r->config_file);
6115         ndr->depth++;
6116         if (r->config_file) {
6117                 ndr_print_string(ndr, "config_file", r->config_file);
6118         }
6119         ndr->depth--;
6120         ndr_print_ptr(ndr, "help_file", r->help_file);
6121         ndr->depth++;
6122         if (r->help_file) {
6123                 ndr_print_string(ndr, "help_file", r->help_file);
6124         }
6125         ndr->depth--;
6126         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6127         ndr->depth++;
6128         if (r->monitor_name) {
6129                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6130         }
6131         ndr->depth--;
6132         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6133         ndr->depth++;
6134         if (r->default_datatype) {
6135                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6136         }
6137         ndr->depth--;
6138         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);
6139         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6140         ndr->depth++;
6141         if (r->dependent_files) {
6142                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6143         }
6144         ndr->depth--;
6145         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);
6146         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6147         ndr->depth++;
6148         if (r->previous_names) {
6149                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6150         }
6151         ndr->depth--;
6152         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6153         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6154         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6155         ndr->depth++;
6156         if (r->manufacturer_name) {
6157                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6158         }
6159         ndr->depth--;
6160         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6161         ndr->depth++;
6162         if (r->manufacturer_url) {
6163                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6164         }
6165         ndr->depth--;
6166         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6167         ndr->depth++;
6168         if (r->hardware_id) {
6169                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6170         }
6171         ndr->depth--;
6172         ndr_print_ptr(ndr, "provider", r->provider);
6173         ndr->depth++;
6174         if (r->provider) {
6175                 ndr_print_string(ndr, "provider", r->provider);
6176         }
6177         ndr->depth--;
6178         ndr->depth--;
6179 }
6180
6181 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
6182 {
6183         if (ndr_flags & NDR_SCALARS) {
6184                 NDR_CHECK(ndr_push_align(ndr, 8));
6185                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
6188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
6189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
6190                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
6191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
6192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
6193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
6194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6195                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
6196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
6198                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
6199                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
6200                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
6201                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
6202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
6203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
6204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
6205                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
6206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6207                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
6208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
6209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
6210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
6212                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
6213                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
6214         }
6215         if (ndr_flags & NDR_BUFFERS) {
6216                 if (r->driver_name) {
6217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6220                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6221                 }
6222                 if (r->architecture) {
6223                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6226                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6227                 }
6228                 if (r->driver_path) {
6229                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6230                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6232                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6233                 }
6234                 if (r->data_file) {
6235                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6236                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6237                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6238                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6239                 }
6240                 if (r->config_file) {
6241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6244                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6245                 }
6246                 if (r->help_file) {
6247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6251                 }
6252                 if (r->monitor_name) {
6253                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6254                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6256                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6257                 }
6258                 if (r->default_datatype) {
6259                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6262                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6263                 }
6264                 if (r->dependent_files) {
6265                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6266                 }
6267                 if (r->previous_names) {
6268                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6269                 }
6270                 if (r->manufacturer_name) {
6271                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
6274                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6275                 }
6276                 if (r->manufacturer_url) {
6277                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
6280                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6281                 }
6282                 if (r->hardware_id) {
6283                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6284                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
6286                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6287                 }
6288                 if (r->provider) {
6289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
6290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
6292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6293                 }
6294                 if (r->print_processor) {
6295                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6298                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6299                 }
6300                 if (r->vendor_setup) {
6301                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6302                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6303                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
6304                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6305                 }
6306                 if (r->color_profiles) {
6307                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6308                 }
6309                 if (r->inf_path) {
6310                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
6313                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6314                 }
6315                 if (r->core_driver_dependencies) {
6316                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6317                 }
6318         }
6319         return NDR_ERR_SUCCESS;
6320 }
6321
6322 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
6323 {
6324         uint32_t _ptr_driver_name;
6325         TALLOC_CTX *_mem_save_driver_name_0;
6326         uint32_t _ptr_architecture;
6327         TALLOC_CTX *_mem_save_architecture_0;
6328         uint32_t _ptr_driver_path;
6329         TALLOC_CTX *_mem_save_driver_path_0;
6330         uint32_t _ptr_data_file;
6331         TALLOC_CTX *_mem_save_data_file_0;
6332         uint32_t _ptr_config_file;
6333         TALLOC_CTX *_mem_save_config_file_0;
6334         uint32_t _ptr_help_file;
6335         TALLOC_CTX *_mem_save_help_file_0;
6336         uint32_t _ptr_monitor_name;
6337         TALLOC_CTX *_mem_save_monitor_name_0;
6338         uint32_t _ptr_default_datatype;
6339         TALLOC_CTX *_mem_save_default_datatype_0;
6340         uint32_t _ptr_dependent_files;
6341         TALLOC_CTX *_mem_save_dependent_files_0;
6342         uint32_t _ptr_previous_names;
6343         TALLOC_CTX *_mem_save_previous_names_0;
6344         uint32_t _ptr_manufacturer_name;
6345         TALLOC_CTX *_mem_save_manufacturer_name_0;
6346         uint32_t _ptr_manufacturer_url;
6347         TALLOC_CTX *_mem_save_manufacturer_url_0;
6348         uint32_t _ptr_hardware_id;
6349         TALLOC_CTX *_mem_save_hardware_id_0;
6350         uint32_t _ptr_provider;
6351         TALLOC_CTX *_mem_save_provider_0;
6352         uint32_t _ptr_print_processor;
6353         TALLOC_CTX *_mem_save_print_processor_0;
6354         uint32_t _ptr_vendor_setup;
6355         TALLOC_CTX *_mem_save_vendor_setup_0;
6356         uint32_t _ptr_color_profiles;
6357         TALLOC_CTX *_mem_save_color_profiles_0;
6358         uint32_t _ptr_inf_path;
6359         TALLOC_CTX *_mem_save_inf_path_0;
6360         uint32_t _ptr_core_driver_dependencies;
6361         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
6362         if (ndr_flags & NDR_SCALARS) {
6363                 NDR_CHECK(ndr_pull_align(ndr, 8));
6364                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6365                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6366                 if (_ptr_driver_name) {
6367                         NDR_PULL_ALLOC(ndr, r->driver_name);
6368                 } else {
6369                         r->driver_name = NULL;
6370                 }
6371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6372                 if (_ptr_architecture) {
6373                         NDR_PULL_ALLOC(ndr, r->architecture);
6374                 } else {
6375                         r->architecture = NULL;
6376                 }
6377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6378                 if (_ptr_driver_path) {
6379                         NDR_PULL_ALLOC(ndr, r->driver_path);
6380                 } else {
6381                         r->driver_path = NULL;
6382                 }
6383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6384                 if (_ptr_data_file) {
6385                         NDR_PULL_ALLOC(ndr, r->data_file);
6386                 } else {
6387                         r->data_file = NULL;
6388                 }
6389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6390                 if (_ptr_config_file) {
6391                         NDR_PULL_ALLOC(ndr, r->config_file);
6392                 } else {
6393                         r->config_file = NULL;
6394                 }
6395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
6396                 if (_ptr_help_file) {
6397                         NDR_PULL_ALLOC(ndr, r->help_file);
6398                 } else {
6399                         r->help_file = NULL;
6400                 }
6401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
6402                 if (_ptr_monitor_name) {
6403                         NDR_PULL_ALLOC(ndr, r->monitor_name);
6404                 } else {
6405                         r->monitor_name = NULL;
6406                 }
6407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
6408                 if (_ptr_default_datatype) {
6409                         NDR_PULL_ALLOC(ndr, r->default_datatype);
6410                 } else {
6411                         r->default_datatype = NULL;
6412                 }
6413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
6414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
6415                 if (_ptr_dependent_files) {
6416                         NDR_PULL_ALLOC(ndr, r->dependent_files);
6417                 } else {
6418                         r->dependent_files = NULL;
6419                 }
6420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
6421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
6422                 if (_ptr_previous_names) {
6423                         NDR_PULL_ALLOC(ndr, r->previous_names);
6424                 } else {
6425                         r->previous_names = NULL;
6426                 }
6427                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
6428                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
6429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
6430                 if (_ptr_manufacturer_name) {
6431                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
6432                 } else {
6433                         r->manufacturer_name = NULL;
6434                 }
6435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
6436                 if (_ptr_manufacturer_url) {
6437                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
6438                 } else {
6439                         r->manufacturer_url = NULL;
6440                 }
6441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
6442                 if (_ptr_hardware_id) {
6443                         NDR_PULL_ALLOC(ndr, r->hardware_id);
6444                 } else {
6445                         r->hardware_id = NULL;
6446                 }
6447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
6448                 if (_ptr_provider) {
6449                         NDR_PULL_ALLOC(ndr, r->provider);
6450                 } else {
6451                         r->provider = NULL;
6452                 }
6453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
6454                 if (_ptr_print_processor) {
6455                         NDR_PULL_ALLOC(ndr, r->print_processor);
6456                 } else {
6457                         r->print_processor = NULL;
6458                 }
6459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
6460                 if (_ptr_vendor_setup) {
6461                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
6462                 } else {
6463                         r->vendor_setup = NULL;
6464                 }
6465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
6466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
6467                 if (_ptr_color_profiles) {
6468                         NDR_PULL_ALLOC(ndr, r->color_profiles);
6469                 } else {
6470                         r->color_profiles = NULL;
6471                 }
6472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
6473                 if (_ptr_inf_path) {
6474                         NDR_PULL_ALLOC(ndr, r->inf_path);
6475                 } else {
6476                         r->inf_path = NULL;
6477                 }
6478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
6479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
6480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
6481                 if (_ptr_core_driver_dependencies) {
6482                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
6483                 } else {
6484                         r->core_driver_dependencies = NULL;
6485                 }
6486                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
6487                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
6488         }
6489         if (ndr_flags & NDR_BUFFERS) {
6490                 if (r->driver_name) {
6491                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6492                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6493                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6494                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6495                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6496                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
6497                         }
6498                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6499                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6501                 }
6502                 if (r->architecture) {
6503                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6504                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6505                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
6506                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
6507                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
6508                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
6509                         }
6510                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
6511                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
6512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6513                 }
6514                 if (r->driver_path) {
6515                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6516                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6517                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
6518                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
6519                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
6520                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
6521                         }
6522                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
6523                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
6524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6525                 }
6526                 if (r->data_file) {
6527                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6528                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6529                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
6530                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
6531                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
6532                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
6533                         }
6534                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
6535                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
6536                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6537                 }
6538                 if (r->config_file) {
6539                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6540                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6541                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
6542                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
6543                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
6544                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
6545                         }
6546                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
6547                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
6548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6549                 }
6550                 if (r->help_file) {
6551                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6552                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
6553                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
6554                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
6555                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
6556                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
6557                         }
6558                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
6559                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
6560                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
6561                 }
6562                 if (r->monitor_name) {
6563                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6564                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6565                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6566                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6567                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6568                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
6569                         }
6570                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6571                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6573                 }
6574                 if (r->default_datatype) {
6575                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6576                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6577                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6578                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6579                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6580                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
6581                         }
6582                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6583                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6585                 }
6586                 if (r->dependent_files) {
6587                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6588                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6589                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6591                 }
6592                 if (r->previous_names) {
6593                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6594                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6595                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6596                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6597                 }
6598                 if (r->manufacturer_name) {
6599                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6600                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
6601                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
6602                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
6603                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
6604                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
6605                         }
6606                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
6607                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
6608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
6609                 }
6610                 if (r->manufacturer_url) {
6611                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
6612                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
6613                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
6614                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
6615                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
6616                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
6617                         }
6618                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
6619                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
6620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
6621                 }
6622                 if (r->hardware_id) {
6623                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6624                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
6625                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
6626                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
6627                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
6628                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
6629                         }
6630                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
6631                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
6632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
6633                 }
6634                 if (r->provider) {
6635                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
6636                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
6637                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
6638                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
6639                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
6640                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
6641                         }
6642                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
6643                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
6644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
6645                 }
6646                 if (r->print_processor) {
6647                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6648                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6649                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6650                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6651                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6652                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
6653                         }
6654                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6655                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6656                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6657                 }
6658                 if (r->vendor_setup) {
6659                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
6660                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
6661                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
6662                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
6663                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
6664                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
6665                         }
6666                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
6667                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
6668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
6669                 }
6670                 if (r->color_profiles) {
6671                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
6672                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
6673                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
6674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
6675                 }
6676                 if (r->inf_path) {
6677                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6678                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
6679                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
6680                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
6681                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
6682                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
6683                         }
6684                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
6685                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
6686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
6687                 }
6688                 if (r->core_driver_dependencies) {
6689                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
6690                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
6691                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
6692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
6693                 }
6694         }
6695         return NDR_ERR_SUCCESS;
6696 }
6697
6698 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
6699 {
6700         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
6701         ndr->depth++;
6702         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6703         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6704         ndr->depth++;
6705         if (r->driver_name) {
6706                 ndr_print_string(ndr, "driver_name", r->driver_name);
6707         }
6708         ndr->depth--;
6709         ndr_print_ptr(ndr, "architecture", r->architecture);
6710         ndr->depth++;
6711         if (r->architecture) {
6712                 ndr_print_string(ndr, "architecture", r->architecture);
6713         }
6714         ndr->depth--;
6715         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6716         ndr->depth++;
6717         if (r->driver_path) {
6718                 ndr_print_string(ndr, "driver_path", r->driver_path);
6719         }
6720         ndr->depth--;
6721         ndr_print_ptr(ndr, "data_file", r->data_file);
6722         ndr->depth++;
6723         if (r->data_file) {
6724                 ndr_print_string(ndr, "data_file", r->data_file);
6725         }
6726         ndr->depth--;
6727         ndr_print_ptr(ndr, "config_file", r->config_file);
6728         ndr->depth++;
6729         if (r->config_file) {
6730                 ndr_print_string(ndr, "config_file", r->config_file);
6731         }
6732         ndr->depth--;
6733         ndr_print_ptr(ndr, "help_file", r->help_file);
6734         ndr->depth++;
6735         if (r->help_file) {
6736                 ndr_print_string(ndr, "help_file", r->help_file);
6737         }
6738         ndr->depth--;
6739         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6740         ndr->depth++;
6741         if (r->monitor_name) {
6742                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6743         }
6744         ndr->depth--;
6745         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6746         ndr->depth++;
6747         if (r->default_datatype) {
6748                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6749         }
6750         ndr->depth--;
6751         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);
6752         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6753         ndr->depth++;
6754         if (r->dependent_files) {
6755                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6756         }
6757         ndr->depth--;
6758         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);
6759         ndr_print_ptr(ndr, "previous_names", r->previous_names);
6760         ndr->depth++;
6761         if (r->previous_names) {
6762                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
6763         }
6764         ndr->depth--;
6765         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
6766         ndr_print_hyper(ndr, "driver_version", r->driver_version);
6767         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
6768         ndr->depth++;
6769         if (r->manufacturer_name) {
6770                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
6771         }
6772         ndr->depth--;
6773         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
6774         ndr->depth++;
6775         if (r->manufacturer_url) {
6776                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
6777         }
6778         ndr->depth--;
6779         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
6780         ndr->depth++;
6781         if (r->hardware_id) {
6782                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
6783         }
6784         ndr->depth--;
6785         ndr_print_ptr(ndr, "provider", r->provider);
6786         ndr->depth++;
6787         if (r->provider) {
6788                 ndr_print_string(ndr, "provider", r->provider);
6789         }
6790         ndr->depth--;
6791         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6792         ndr->depth++;
6793         if (r->print_processor) {
6794                 ndr_print_string(ndr, "print_processor", r->print_processor);
6795         }
6796         ndr->depth--;
6797         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
6798         ndr->depth++;
6799         if (r->vendor_setup) {
6800                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
6801         }
6802         ndr->depth--;
6803         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);
6804         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
6805         ndr->depth++;
6806         if (r->color_profiles) {
6807                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
6808         }
6809         ndr->depth--;
6810         ndr_print_ptr(ndr, "inf_path", r->inf_path);
6811         ndr->depth++;
6812         if (r->inf_path) {
6813                 ndr_print_string(ndr, "inf_path", r->inf_path);
6814         }
6815         ndr->depth--;
6816         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
6817         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);
6818         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6819         ndr->depth++;
6820         if (r->core_driver_dependencies) {
6821                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
6822         }
6823         ndr->depth--;
6824         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
6825         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
6826         ndr->depth--;
6827 }
6828
6829 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
6830 {
6831         if (ndr_flags & NDR_SCALARS) {
6832                 int level = ndr_push_get_switch_value(ndr, r);
6833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6834                 switch (level) {
6835                         case 1: {
6836                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6837                         break; }
6838
6839                         case 2: {
6840                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6841                         break; }
6842
6843                         case 3: {
6844                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6845                         break; }
6846
6847                         case 4: {
6848                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6849                         break; }
6850
6851                         case 6: {
6852                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6853                         break; }
6854
6855                         case 8: {
6856                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6857                         break; }
6858
6859                         default:
6860                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6861                 }
6862         }
6863         if (ndr_flags & NDR_BUFFERS) {
6864                 int level = ndr_push_get_switch_value(ndr, r);
6865                 switch (level) {
6866                         case 1:
6867                                 if (r->info1) {
6868                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6869                                 }
6870                         break;
6871
6872                         case 2:
6873                                 if (r->info2) {
6874                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6875                                 }
6876                         break;
6877
6878                         case 3:
6879                                 if (r->info3) {
6880                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
6881                                 }
6882                         break;
6883
6884                         case 4:
6885                                 if (r->info4) {
6886                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6887                                 }
6888                         break;
6889
6890                         case 6:
6891                                 if (r->info6) {
6892                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
6893                                 }
6894                         break;
6895
6896                         case 8:
6897                                 if (r->info8) {
6898                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6899                                 }
6900                         break;
6901
6902                         default:
6903                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6904                 }
6905         }
6906         return NDR_ERR_SUCCESS;
6907 }
6908
6909 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
6910 {
6911         int level;
6912         uint32_t _level;
6913         TALLOC_CTX *_mem_save_info1_0;
6914         TALLOC_CTX *_mem_save_info2_0;
6915         TALLOC_CTX *_mem_save_info3_0;
6916         TALLOC_CTX *_mem_save_info4_0;
6917         TALLOC_CTX *_mem_save_info6_0;
6918         TALLOC_CTX *_mem_save_info8_0;
6919         level = ndr_pull_get_switch_value(ndr, r);
6920         if (ndr_flags & NDR_SCALARS) {
6921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6922                 if (_level != level) {
6923                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6924                 }
6925                 switch (level) {
6926                         case 1: {
6927                                 uint32_t _ptr_info1;
6928                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6929                                 if (_ptr_info1) {
6930                                         NDR_PULL_ALLOC(ndr, r->info1);
6931                                 } else {
6932                                         r->info1 = NULL;
6933                                 }
6934                         break; }
6935
6936                         case 2: {
6937                                 uint32_t _ptr_info2;
6938                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6939                                 if (_ptr_info2) {
6940                                         NDR_PULL_ALLOC(ndr, r->info2);
6941                                 } else {
6942                                         r->info2 = NULL;
6943                                 }
6944                         break; }
6945
6946                         case 3: {
6947                                 uint32_t _ptr_info3;
6948                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6949                                 if (_ptr_info3) {
6950                                         NDR_PULL_ALLOC(ndr, r->info3);
6951                                 } else {
6952                                         r->info3 = NULL;
6953                                 }
6954                         break; }
6955
6956                         case 4: {
6957                                 uint32_t _ptr_info4;
6958                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6959                                 if (_ptr_info4) {
6960                                         NDR_PULL_ALLOC(ndr, r->info4);
6961                                 } else {
6962                                         r->info4 = NULL;
6963                                 }
6964                         break; }
6965
6966                         case 6: {
6967                                 uint32_t _ptr_info6;
6968                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
6969                                 if (_ptr_info6) {
6970                                         NDR_PULL_ALLOC(ndr, r->info6);
6971                                 } else {
6972                                         r->info6 = NULL;
6973                                 }
6974                         break; }
6975
6976                         case 8: {
6977                                 uint32_t _ptr_info8;
6978                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
6979                                 if (_ptr_info8) {
6980                                         NDR_PULL_ALLOC(ndr, r->info8);
6981                                 } else {
6982                                         r->info8 = NULL;
6983                                 }
6984                         break; }
6985
6986                         default:
6987                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
6988                 }
6989         }
6990         if (ndr_flags & NDR_BUFFERS) {
6991                 switch (level) {
6992                         case 1:
6993                                 if (r->info1) {
6994                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6995                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6996                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6997                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6998                                 }
6999                         break;
7000
7001                         case 2:
7002                                 if (r->info2) {
7003                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7004                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7005                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7006                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7007                                 }
7008                         break;
7009
7010                         case 3:
7011                                 if (r->info3) {
7012                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7013                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7014                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
7015                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7016                                 }
7017                         break;
7018
7019                         case 4:
7020                                 if (r->info4) {
7021                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7022                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7023                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7024                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7025                                 }
7026                         break;
7027
7028                         case 6:
7029                                 if (r->info6) {
7030                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7031                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7032                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
7033                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7034                                 }
7035                         break;
7036
7037                         case 8:
7038                                 if (r->info8) {
7039                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7040                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7041                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7042                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7043                                 }
7044                         break;
7045
7046                         default:
7047                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7048                 }
7049         }
7050         return NDR_ERR_SUCCESS;
7051 }
7052
7053 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
7054 {
7055         int level;
7056         level = ndr_print_get_switch_value(ndr, r);
7057         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
7058         switch (level) {
7059                 case 1:
7060                         ndr_print_ptr(ndr, "info1", r->info1);
7061                         ndr->depth++;
7062                         if (r->info1) {
7063                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
7064                         }
7065                         ndr->depth--;
7066                 break;
7067
7068                 case 2:
7069                         ndr_print_ptr(ndr, "info2", r->info2);
7070                         ndr->depth++;
7071                         if (r->info2) {
7072                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
7073                         }
7074                         ndr->depth--;
7075                 break;
7076
7077                 case 3:
7078                         ndr_print_ptr(ndr, "info3", r->info3);
7079                         ndr->depth++;
7080                         if (r->info3) {
7081                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
7082                         }
7083                         ndr->depth--;
7084                 break;
7085
7086                 case 4:
7087                         ndr_print_ptr(ndr, "info4", r->info4);
7088                         ndr->depth++;
7089                         if (r->info4) {
7090                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
7091                         }
7092                         ndr->depth--;
7093                 break;
7094
7095                 case 6:
7096                         ndr_print_ptr(ndr, "info6", r->info6);
7097                         ndr->depth++;
7098                         if (r->info6) {
7099                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
7100                         }
7101                         ndr->depth--;
7102                 break;
7103
7104                 case 8:
7105                         ndr_print_ptr(ndr, "info8", r->info8);
7106                         ndr->depth++;
7107                         if (r->info8) {
7108                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
7109                         }
7110                         ndr->depth--;
7111                 break;
7112
7113                 default:
7114                         ndr_print_bad_level(ndr, name, level);
7115         }
7116 }
7117
7118 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
7119 {
7120         if (ndr_flags & NDR_SCALARS) {
7121                 NDR_CHECK(ndr_push_align(ndr, 4));
7122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7123                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7124                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7125         }
7126         if (ndr_flags & NDR_BUFFERS) {
7127                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7128         }
7129         return NDR_ERR_SUCCESS;
7130 }
7131
7132 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
7133 {
7134         if (ndr_flags & NDR_SCALARS) {
7135                 NDR_CHECK(ndr_pull_align(ndr, 4));
7136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7137                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7138                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
7139         }
7140         if (ndr_flags & NDR_BUFFERS) {
7141                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
7142         }
7143         return NDR_ERR_SUCCESS;
7144 }
7145
7146 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
7147 {
7148         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
7149         ndr->depth++;
7150         ndr_print_uint32(ndr, "level", r->level);
7151         ndr_print_set_switch_value(ndr, &r->info, r->level);
7152         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
7153         ndr->depth--;
7154 }
7155
7156 static enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
7157 {
7158         if (ndr_flags & NDR_SCALARS) {
7159                 NDR_CHECK(ndr_push_align(ndr, 4));
7160                 {
7161                         uint32_t _flags_save_string = ndr->flags;
7162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7163                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7164                         ndr->flags = _flags_save_string;
7165                 }
7166         }
7167         if (ndr_flags & NDR_BUFFERS) {
7168                 {
7169                         uint32_t _flags_save_string = ndr->flags;
7170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7171                         if (r->driver_name) {
7172                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7173                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7174                         }
7175                         ndr->flags = _flags_save_string;
7176                 }
7177         }
7178         return NDR_ERR_SUCCESS;
7179 }
7180
7181 static enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
7182 {
7183         uint32_t _ptr_driver_name;
7184         TALLOC_CTX *_mem_save_driver_name_0;
7185         if (ndr_flags & NDR_SCALARS) {
7186                 NDR_CHECK(ndr_pull_align(ndr, 4));
7187                 {
7188                         uint32_t _flags_save_string = ndr->flags;
7189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7190                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7191                         if (_ptr_driver_name) {
7192                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7193                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7194                         } else {
7195                                 r->driver_name = NULL;
7196                         }
7197                         ndr->flags = _flags_save_string;
7198                 }
7199         }
7200         if (ndr_flags & NDR_BUFFERS) {
7201                 {
7202                         uint32_t _flags_save_string = ndr->flags;
7203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7204                         if (r->driver_name) {
7205                                 uint32_t _relative_save_offset;
7206                                 _relative_save_offset = ndr->offset;
7207                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7208                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7209                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7210                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7211                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7212                                 ndr->offset = _relative_save_offset;
7213                         }
7214                         ndr->flags = _flags_save_string;
7215                 }
7216         }
7217         return NDR_ERR_SUCCESS;
7218 }
7219
7220 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
7221 {
7222         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
7223         ndr->depth++;
7224         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7225         ndr->depth++;
7226         if (r->driver_name) {
7227                 ndr_print_string(ndr, "driver_name", r->driver_name);
7228         }
7229         ndr->depth--;
7230         ndr->depth--;
7231 }
7232
7233 static enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
7234 {
7235         if (ndr_flags & NDR_SCALARS) {
7236                 NDR_CHECK(ndr_push_align(ndr, 4));
7237                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7238                 {
7239                         uint32_t _flags_save_string = ndr->flags;
7240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7242                         ndr->flags = _flags_save_string;
7243                 }
7244                 {
7245                         uint32_t _flags_save_string = ndr->flags;
7246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7247                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7248                         ndr->flags = _flags_save_string;
7249                 }
7250                 {
7251                         uint32_t _flags_save_string = ndr->flags;
7252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7253                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7254                         ndr->flags = _flags_save_string;
7255                 }
7256                 {
7257                         uint32_t _flags_save_string = ndr->flags;
7258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7260                         ndr->flags = _flags_save_string;
7261                 }
7262                 {
7263                         uint32_t _flags_save_string = ndr->flags;
7264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7266                         ndr->flags = _flags_save_string;
7267                 }
7268         }
7269         if (ndr_flags & NDR_BUFFERS) {
7270                 {
7271                         uint32_t _flags_save_string = ndr->flags;
7272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7273                         if (r->driver_name) {
7274                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7275                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7276                         }
7277                         ndr->flags = _flags_save_string;
7278                 }
7279                 {
7280                         uint32_t _flags_save_string = ndr->flags;
7281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7282                         if (r->architecture) {
7283                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7284                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7285                         }
7286                         ndr->flags = _flags_save_string;
7287                 }
7288                 {
7289                         uint32_t _flags_save_string = ndr->flags;
7290                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7291                         if (r->driver_path) {
7292                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7293                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7294                         }
7295                         ndr->flags = _flags_save_string;
7296                 }
7297                 {
7298                         uint32_t _flags_save_string = ndr->flags;
7299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7300                         if (r->data_file) {
7301                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7302                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7303                         }
7304                         ndr->flags = _flags_save_string;
7305                 }
7306                 {
7307                         uint32_t _flags_save_string = ndr->flags;
7308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7309                         if (r->config_file) {
7310                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7311                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7312                         }
7313                         ndr->flags = _flags_save_string;
7314                 }
7315         }
7316         return NDR_ERR_SUCCESS;
7317 }
7318
7319 static enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
7320 {
7321         uint32_t _ptr_driver_name;
7322         TALLOC_CTX *_mem_save_driver_name_0;
7323         uint32_t _ptr_architecture;
7324         TALLOC_CTX *_mem_save_architecture_0;
7325         uint32_t _ptr_driver_path;
7326         TALLOC_CTX *_mem_save_driver_path_0;
7327         uint32_t _ptr_data_file;
7328         TALLOC_CTX *_mem_save_data_file_0;
7329         uint32_t _ptr_config_file;
7330         TALLOC_CTX *_mem_save_config_file_0;
7331         if (ndr_flags & NDR_SCALARS) {
7332                 NDR_CHECK(ndr_pull_align(ndr, 4));
7333                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7334                 {
7335                         uint32_t _flags_save_string = ndr->flags;
7336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7337                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7338                         if (_ptr_driver_name) {
7339                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7340                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7341                         } else {
7342                                 r->driver_name = NULL;
7343                         }
7344                         ndr->flags = _flags_save_string;
7345                 }
7346                 {
7347                         uint32_t _flags_save_string = ndr->flags;
7348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7349                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7350                         if (_ptr_architecture) {
7351                                 NDR_PULL_ALLOC(ndr, r->architecture);
7352                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7353                         } else {
7354                                 r->architecture = NULL;
7355                         }
7356                         ndr->flags = _flags_save_string;
7357                 }
7358                 {
7359                         uint32_t _flags_save_string = ndr->flags;
7360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7361                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7362                         if (_ptr_driver_path) {
7363                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7364                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7365                         } else {
7366                                 r->driver_path = NULL;
7367                         }
7368                         ndr->flags = _flags_save_string;
7369                 }
7370                 {
7371                         uint32_t _flags_save_string = ndr->flags;
7372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7373                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7374                         if (_ptr_data_file) {
7375                                 NDR_PULL_ALLOC(ndr, r->data_file);
7376                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7377                         } else {
7378                                 r->data_file = NULL;
7379                         }
7380                         ndr->flags = _flags_save_string;
7381                 }
7382                 {
7383                         uint32_t _flags_save_string = ndr->flags;
7384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7386                         if (_ptr_config_file) {
7387                                 NDR_PULL_ALLOC(ndr, r->config_file);
7388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7389                         } else {
7390                                 r->config_file = NULL;
7391                         }
7392                         ndr->flags = _flags_save_string;
7393                 }
7394         }
7395         if (ndr_flags & NDR_BUFFERS) {
7396                 {
7397                         uint32_t _flags_save_string = ndr->flags;
7398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7399                         if (r->driver_name) {
7400                                 uint32_t _relative_save_offset;
7401                                 _relative_save_offset = ndr->offset;
7402                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7403                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7404                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7405                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7406                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7407                                 ndr->offset = _relative_save_offset;
7408                         }
7409                         ndr->flags = _flags_save_string;
7410                 }
7411                 {
7412                         uint32_t _flags_save_string = ndr->flags;
7413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7414                         if (r->architecture) {
7415                                 uint32_t _relative_save_offset;
7416                                 _relative_save_offset = ndr->offset;
7417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7418                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7419                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7422                                 ndr->offset = _relative_save_offset;
7423                         }
7424                         ndr->flags = _flags_save_string;
7425                 }
7426                 {
7427                         uint32_t _flags_save_string = ndr->flags;
7428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7429                         if (r->driver_path) {
7430                                 uint32_t _relative_save_offset;
7431                                 _relative_save_offset = ndr->offset;
7432                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7433                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7434                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7435                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7436                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7437                                 ndr->offset = _relative_save_offset;
7438                         }
7439                         ndr->flags = _flags_save_string;
7440                 }
7441                 {
7442                         uint32_t _flags_save_string = ndr->flags;
7443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7444                         if (r->data_file) {
7445                                 uint32_t _relative_save_offset;
7446                                 _relative_save_offset = ndr->offset;
7447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7448                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7449                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7452                                 ndr->offset = _relative_save_offset;
7453                         }
7454                         ndr->flags = _flags_save_string;
7455                 }
7456                 {
7457                         uint32_t _flags_save_string = ndr->flags;
7458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7459                         if (r->config_file) {
7460                                 uint32_t _relative_save_offset;
7461                                 _relative_save_offset = ndr->offset;
7462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7463                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7464                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7467                                 ndr->offset = _relative_save_offset;
7468                         }
7469                         ndr->flags = _flags_save_string;
7470                 }
7471         }
7472         return NDR_ERR_SUCCESS;
7473 }
7474
7475 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
7476 {
7477         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
7478         ndr->depth++;
7479         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7480         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7481         ndr->depth++;
7482         if (r->driver_name) {
7483                 ndr_print_string(ndr, "driver_name", r->driver_name);
7484         }
7485         ndr->depth--;
7486         ndr_print_ptr(ndr, "architecture", r->architecture);
7487         ndr->depth++;
7488         if (r->architecture) {
7489                 ndr_print_string(ndr, "architecture", r->architecture);
7490         }
7491         ndr->depth--;
7492         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7493         ndr->depth++;
7494         if (r->driver_path) {
7495                 ndr_print_string(ndr, "driver_path", r->driver_path);
7496         }
7497         ndr->depth--;
7498         ndr_print_ptr(ndr, "data_file", r->data_file);
7499         ndr->depth++;
7500         if (r->data_file) {
7501                 ndr_print_string(ndr, "data_file", r->data_file);
7502         }
7503         ndr->depth--;
7504         ndr_print_ptr(ndr, "config_file", r->config_file);
7505         ndr->depth++;
7506         if (r->config_file) {
7507                 ndr_print_string(ndr, "config_file", r->config_file);
7508         }
7509         ndr->depth--;
7510         ndr->depth--;
7511 }
7512
7513 static enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
7514 {
7515         if (ndr_flags & NDR_SCALARS) {
7516                 NDR_CHECK(ndr_push_align(ndr, 4));
7517                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7518                 {
7519                         uint32_t _flags_save_string = ndr->flags;
7520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7521                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
7522                         ndr->flags = _flags_save_string;
7523                 }
7524                 {
7525                         uint32_t _flags_save_string = ndr->flags;
7526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7527                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
7528                         ndr->flags = _flags_save_string;
7529                 }
7530                 {
7531                         uint32_t _flags_save_string = ndr->flags;
7532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7533                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
7534                         ndr->flags = _flags_save_string;
7535                 }
7536                 {
7537                         uint32_t _flags_save_string = ndr->flags;
7538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7539                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
7540                         ndr->flags = _flags_save_string;
7541                 }
7542                 {
7543                         uint32_t _flags_save_string = ndr->flags;
7544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7545                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
7546                         ndr->flags = _flags_save_string;
7547                 }
7548                 {
7549                         uint32_t _flags_save_string = ndr->flags;
7550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7551                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
7552                         ndr->flags = _flags_save_string;
7553                 }
7554                 {
7555                         uint32_t _flags_save_string_array = ndr->flags;
7556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7557                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
7558                         ndr->flags = _flags_save_string_array;
7559                 }
7560                 {
7561                         uint32_t _flags_save_string = ndr->flags;
7562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7563                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7564                         ndr->flags = _flags_save_string;
7565                 }
7566                 {
7567                         uint32_t _flags_save_string = ndr->flags;
7568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
7570                         ndr->flags = _flags_save_string;
7571                 }
7572         }
7573         if (ndr_flags & NDR_BUFFERS) {
7574                 {
7575                         uint32_t _flags_save_string = ndr->flags;
7576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7577                         if (r->driver_name) {
7578                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
7579                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
7580                         }
7581                         ndr->flags = _flags_save_string;
7582                 }
7583                 {
7584                         uint32_t _flags_save_string = ndr->flags;
7585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7586                         if (r->architecture) {
7587                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
7588                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
7589                         }
7590                         ndr->flags = _flags_save_string;
7591                 }
7592                 {
7593                         uint32_t _flags_save_string = ndr->flags;
7594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7595                         if (r->driver_path) {
7596                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
7597                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
7598                         }
7599                         ndr->flags = _flags_save_string;
7600                 }
7601                 {
7602                         uint32_t _flags_save_string = ndr->flags;
7603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7604                         if (r->data_file) {
7605                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
7606                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
7607                         }
7608                         ndr->flags = _flags_save_string;
7609                 }
7610                 {
7611                         uint32_t _flags_save_string = ndr->flags;
7612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7613                         if (r->config_file) {
7614                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
7615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
7616                         }
7617                         ndr->flags = _flags_save_string;
7618                 }
7619                 {
7620                         uint32_t _flags_save_string = ndr->flags;
7621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7622                         if (r->help_file) {
7623                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
7624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
7625                         }
7626                         ndr->flags = _flags_save_string;
7627                 }
7628                 {
7629                         uint32_t _flags_save_string_array = ndr->flags;
7630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7631                         if (r->dependent_files) {
7632                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
7633                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
7634                         }
7635                         ndr->flags = _flags_save_string_array;
7636                 }
7637                 {
7638                         uint32_t _flags_save_string = ndr->flags;
7639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7640                         if (r->monitor_name) {
7641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7643                         }
7644                         ndr->flags = _flags_save_string;
7645                 }
7646                 {
7647                         uint32_t _flags_save_string = ndr->flags;
7648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7649                         if (r->default_datatype) {
7650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
7651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
7652                         }
7653                         ndr->flags = _flags_save_string;
7654                 }
7655         }
7656         return NDR_ERR_SUCCESS;
7657 }
7658
7659 static enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
7660 {
7661         uint32_t _ptr_driver_name;
7662         TALLOC_CTX *_mem_save_driver_name_0;
7663         uint32_t _ptr_architecture;
7664         TALLOC_CTX *_mem_save_architecture_0;
7665         uint32_t _ptr_driver_path;
7666         TALLOC_CTX *_mem_save_driver_path_0;
7667         uint32_t _ptr_data_file;
7668         TALLOC_CTX *_mem_save_data_file_0;
7669         uint32_t _ptr_config_file;
7670         TALLOC_CTX *_mem_save_config_file_0;
7671         uint32_t _ptr_help_file;
7672         TALLOC_CTX *_mem_save_help_file_0;
7673         uint32_t _ptr_dependent_files;
7674         TALLOC_CTX *_mem_save_dependent_files_0;
7675         uint32_t _ptr_monitor_name;
7676         TALLOC_CTX *_mem_save_monitor_name_0;
7677         uint32_t _ptr_default_datatype;
7678         TALLOC_CTX *_mem_save_default_datatype_0;
7679         if (ndr_flags & NDR_SCALARS) {
7680                 NDR_CHECK(ndr_pull_align(ndr, 4));
7681                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7682                 {
7683                         uint32_t _flags_save_string = ndr->flags;
7684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7685                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7686                         if (_ptr_driver_name) {
7687                                 NDR_PULL_ALLOC(ndr, r->driver_name);
7688                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
7689                         } else {
7690                                 r->driver_name = NULL;
7691                         }
7692                         ndr->flags = _flags_save_string;
7693                 }
7694                 {
7695                         uint32_t _flags_save_string = ndr->flags;
7696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7697                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7698                         if (_ptr_architecture) {
7699                                 NDR_PULL_ALLOC(ndr, r->architecture);
7700                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
7701                         } else {
7702                                 r->architecture = NULL;
7703                         }
7704                         ndr->flags = _flags_save_string;
7705                 }
7706                 {
7707                         uint32_t _flags_save_string = ndr->flags;
7708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7709                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7710                         if (_ptr_driver_path) {
7711                                 NDR_PULL_ALLOC(ndr, r->driver_path);
7712                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
7713                         } else {
7714                                 r->driver_path = NULL;
7715                         }
7716                         ndr->flags = _flags_save_string;
7717                 }
7718                 {
7719                         uint32_t _flags_save_string = ndr->flags;
7720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7721                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7722                         if (_ptr_data_file) {
7723                                 NDR_PULL_ALLOC(ndr, r->data_file);
7724                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
7725                         } else {
7726                                 r->data_file = NULL;
7727                         }
7728                         ndr->flags = _flags_save_string;
7729                 }
7730                 {
7731                         uint32_t _flags_save_string = ndr->flags;
7732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7733                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7734                         if (_ptr_config_file) {
7735                                 NDR_PULL_ALLOC(ndr, r->config_file);
7736                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
7737                         } else {
7738                                 r->config_file = NULL;
7739                         }
7740                         ndr->flags = _flags_save_string;
7741                 }
7742                 {
7743                         uint32_t _flags_save_string = ndr->flags;
7744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7745                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7746                         if (_ptr_help_file) {
7747                                 NDR_PULL_ALLOC(ndr, r->help_file);
7748                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
7749                         } else {
7750                                 r->help_file = NULL;
7751                         }
7752                         ndr->flags = _flags_save_string;
7753                 }
7754                 {
7755                         uint32_t _flags_save_string_array = ndr->flags;
7756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7757                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7758                         if (_ptr_dependent_files) {
7759                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
7760                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
7761                         } else {
7762                                 r->dependent_files = NULL;
7763                         }
7764                         ndr->flags = _flags_save_string_array;
7765                 }
7766                 {
7767                         uint32_t _flags_save_string = ndr->flags;
7768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7769                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7770                         if (_ptr_monitor_name) {
7771                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7772                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7773                         } else {
7774                                 r->monitor_name = NULL;
7775                         }
7776                         ndr->flags = _flags_save_string;
7777                 }
7778                 {
7779                         uint32_t _flags_save_string = ndr->flags;
7780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7781                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7782                         if (_ptr_default_datatype) {
7783                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
7784                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
7785                         } else {
7786                                 r->default_datatype = NULL;
7787                         }
7788                         ndr->flags = _flags_save_string;
7789                 }
7790         }
7791         if (ndr_flags & NDR_BUFFERS) {
7792                 {
7793                         uint32_t _flags_save_string = ndr->flags;
7794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7795                         if (r->driver_name) {
7796                                 uint32_t _relative_save_offset;
7797                                 _relative_save_offset = ndr->offset;
7798                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
7799                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7800                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7801                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
7802                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7803                                 ndr->offset = _relative_save_offset;
7804                         }
7805                         ndr->flags = _flags_save_string;
7806                 }
7807                 {
7808                         uint32_t _flags_save_string = ndr->flags;
7809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7810                         if (r->architecture) {
7811                                 uint32_t _relative_save_offset;
7812                                 _relative_save_offset = ndr->offset;
7813                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
7814                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7815                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7816                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
7817                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7818                                 ndr->offset = _relative_save_offset;
7819                         }
7820                         ndr->flags = _flags_save_string;
7821                 }
7822                 {
7823                         uint32_t _flags_save_string = ndr->flags;
7824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7825                         if (r->driver_path) {
7826                                 uint32_t _relative_save_offset;
7827                                 _relative_save_offset = ndr->offset;
7828                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
7829                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7830                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7831                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
7832                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7833                                 ndr->offset = _relative_save_offset;
7834                         }
7835                         ndr->flags = _flags_save_string;
7836                 }
7837                 {
7838                         uint32_t _flags_save_string = ndr->flags;
7839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7840                         if (r->data_file) {
7841                                 uint32_t _relative_save_offset;
7842                                 _relative_save_offset = ndr->offset;
7843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
7844                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7845                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
7847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7848                                 ndr->offset = _relative_save_offset;
7849                         }
7850                         ndr->flags = _flags_save_string;
7851                 }
7852                 {
7853                         uint32_t _flags_save_string = ndr->flags;
7854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7855                         if (r->config_file) {
7856                                 uint32_t _relative_save_offset;
7857                                 _relative_save_offset = ndr->offset;
7858                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
7859                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7860                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7861                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
7862                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7863                                 ndr->offset = _relative_save_offset;
7864                         }
7865                         ndr->flags = _flags_save_string;
7866                 }
7867                 {
7868                         uint32_t _flags_save_string = ndr->flags;
7869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7870                         if (r->help_file) {
7871                                 uint32_t _relative_save_offset;
7872                                 _relative_save_offset = ndr->offset;
7873                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
7874                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7875                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7876                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
7877                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7878                                 ndr->offset = _relative_save_offset;
7879                         }
7880                         ndr->flags = _flags_save_string;
7881                 }
7882                 {
7883                         uint32_t _flags_save_string_array = ndr->flags;
7884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7885                         if (r->dependent_files) {
7886                                 uint32_t _relative_save_offset;
7887                                 _relative_save_offset = ndr->offset;
7888                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
7889                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7890                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7891                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
7892                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7893                                 ndr->offset = _relative_save_offset;
7894                         }
7895                         ndr->flags = _flags_save_string_array;
7896                 }
7897                 {
7898                         uint32_t _flags_save_string = ndr->flags;
7899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7900                         if (r->monitor_name) {
7901                                 uint32_t _relative_save_offset;
7902                                 _relative_save_offset = ndr->offset;
7903                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7904                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7905                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7906                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7907                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7908                                 ndr->offset = _relative_save_offset;
7909                         }
7910                         ndr->flags = _flags_save_string;
7911                 }
7912                 {
7913                         uint32_t _flags_save_string = ndr->flags;
7914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7915                         if (r->default_datatype) {
7916                                 uint32_t _relative_save_offset;
7917                                 _relative_save_offset = ndr->offset;
7918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
7919                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7920                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
7922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7923                                 ndr->offset = _relative_save_offset;
7924                         }
7925                         ndr->flags = _flags_save_string;
7926                 }
7927         }
7928         return NDR_ERR_SUCCESS;
7929 }
7930
7931 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
7932 {
7933         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
7934         ndr->depth++;
7935         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7936         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7937         ndr->depth++;
7938         if (r->driver_name) {
7939                 ndr_print_string(ndr, "driver_name", r->driver_name);
7940         }
7941         ndr->depth--;
7942         ndr_print_ptr(ndr, "architecture", r->architecture);
7943         ndr->depth++;
7944         if (r->architecture) {
7945                 ndr_print_string(ndr, "architecture", r->architecture);
7946         }
7947         ndr->depth--;
7948         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7949         ndr->depth++;
7950         if (r->driver_path) {
7951                 ndr_print_string(ndr, "driver_path", r->driver_path);
7952         }
7953         ndr->depth--;
7954         ndr_print_ptr(ndr, "data_file", r->data_file);
7955         ndr->depth++;
7956         if (r->data_file) {
7957                 ndr_print_string(ndr, "data_file", r->data_file);
7958         }
7959         ndr->depth--;
7960         ndr_print_ptr(ndr, "config_file", r->config_file);
7961         ndr->depth++;
7962         if (r->config_file) {
7963                 ndr_print_string(ndr, "config_file", r->config_file);
7964         }
7965         ndr->depth--;
7966         ndr_print_ptr(ndr, "help_file", r->help_file);
7967         ndr->depth++;
7968         if (r->help_file) {
7969                 ndr_print_string(ndr, "help_file", r->help_file);
7970         }
7971         ndr->depth--;
7972         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7973         ndr->depth++;
7974         if (r->dependent_files) {
7975                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
7976         }
7977         ndr->depth--;
7978         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7979         ndr->depth++;
7980         if (r->monitor_name) {
7981                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7982         }
7983         ndr->depth--;
7984         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7985         ndr->depth++;
7986         if (r->default_datatype) {
7987                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7988         }
7989         ndr->depth--;
7990         ndr->depth--;
7991 }
7992
7993 static enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
7994 {
7995         if (ndr_flags & NDR_SCALARS) {
7996                 NDR_CHECK(ndr_push_align(ndr, 4));
7997                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7998                 {
7999                         uint32_t _flags_save_string = ndr->flags;
8000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8002                         ndr->flags = _flags_save_string;
8003                 }
8004                 {
8005                         uint32_t _flags_save_string = ndr->flags;
8006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8008                         ndr->flags = _flags_save_string;
8009                 }
8010                 {
8011                         uint32_t _flags_save_string = ndr->flags;
8012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8014                         ndr->flags = _flags_save_string;
8015                 }
8016                 {
8017                         uint32_t _flags_save_string = ndr->flags;
8018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8020                         ndr->flags = _flags_save_string;
8021                 }
8022                 {
8023                         uint32_t _flags_save_string = ndr->flags;
8024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8026                         ndr->flags = _flags_save_string;
8027                 }
8028                 {
8029                         uint32_t _flags_save_string = ndr->flags;
8030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8031                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8032                         ndr->flags = _flags_save_string;
8033                 }
8034                 {
8035                         uint32_t _flags_save_string_array = ndr->flags;
8036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8037                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8038                         ndr->flags = _flags_save_string_array;
8039                 }
8040                 {
8041                         uint32_t _flags_save_string = ndr->flags;
8042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8043                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8044                         ndr->flags = _flags_save_string;
8045                 }
8046                 {
8047                         uint32_t _flags_save_string = ndr->flags;
8048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8049                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8050                         ndr->flags = _flags_save_string;
8051                 }
8052                 {
8053                         uint32_t _flags_save_string_array = ndr->flags;
8054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8055                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8056                         ndr->flags = _flags_save_string_array;
8057                 }
8058         }
8059         if (ndr_flags & NDR_BUFFERS) {
8060                 {
8061                         uint32_t _flags_save_string = ndr->flags;
8062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8063                         if (r->driver_name) {
8064                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8065                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8066                         }
8067                         ndr->flags = _flags_save_string;
8068                 }
8069                 {
8070                         uint32_t _flags_save_string = ndr->flags;
8071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8072                         if (r->architecture) {
8073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8075                         }
8076                         ndr->flags = _flags_save_string;
8077                 }
8078                 {
8079                         uint32_t _flags_save_string = ndr->flags;
8080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8081                         if (r->driver_path) {
8082                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8084                         }
8085                         ndr->flags = _flags_save_string;
8086                 }
8087                 {
8088                         uint32_t _flags_save_string = ndr->flags;
8089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8090                         if (r->data_file) {
8091                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8093                         }
8094                         ndr->flags = _flags_save_string;
8095                 }
8096                 {
8097                         uint32_t _flags_save_string = ndr->flags;
8098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8099                         if (r->config_file) {
8100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8102                         }
8103                         ndr->flags = _flags_save_string;
8104                 }
8105                 {
8106                         uint32_t _flags_save_string = ndr->flags;
8107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8108                         if (r->help_file) {
8109                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8110                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8111                         }
8112                         ndr->flags = _flags_save_string;
8113                 }
8114                 {
8115                         uint32_t _flags_save_string_array = ndr->flags;
8116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8117                         if (r->dependent_files) {
8118                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8119                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8120                         }
8121                         ndr->flags = _flags_save_string_array;
8122                 }
8123                 {
8124                         uint32_t _flags_save_string = ndr->flags;
8125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8126                         if (r->monitor_name) {
8127                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8128                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8129                         }
8130                         ndr->flags = _flags_save_string;
8131                 }
8132                 {
8133                         uint32_t _flags_save_string = ndr->flags;
8134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8135                         if (r->default_datatype) {
8136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8138                         }
8139                         ndr->flags = _flags_save_string;
8140                 }
8141                 {
8142                         uint32_t _flags_save_string_array = ndr->flags;
8143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8144                         if (r->previous_names) {
8145                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8146                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8147                         }
8148                         ndr->flags = _flags_save_string_array;
8149                 }
8150         }
8151         return NDR_ERR_SUCCESS;
8152 }
8153
8154 static enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
8155 {
8156         uint32_t _ptr_driver_name;
8157         TALLOC_CTX *_mem_save_driver_name_0;
8158         uint32_t _ptr_architecture;
8159         TALLOC_CTX *_mem_save_architecture_0;
8160         uint32_t _ptr_driver_path;
8161         TALLOC_CTX *_mem_save_driver_path_0;
8162         uint32_t _ptr_data_file;
8163         TALLOC_CTX *_mem_save_data_file_0;
8164         uint32_t _ptr_config_file;
8165         TALLOC_CTX *_mem_save_config_file_0;
8166         uint32_t _ptr_help_file;
8167         TALLOC_CTX *_mem_save_help_file_0;
8168         uint32_t _ptr_dependent_files;
8169         TALLOC_CTX *_mem_save_dependent_files_0;
8170         uint32_t _ptr_monitor_name;
8171         TALLOC_CTX *_mem_save_monitor_name_0;
8172         uint32_t _ptr_default_datatype;
8173         TALLOC_CTX *_mem_save_default_datatype_0;
8174         uint32_t _ptr_previous_names;
8175         TALLOC_CTX *_mem_save_previous_names_0;
8176         if (ndr_flags & NDR_SCALARS) {
8177                 NDR_CHECK(ndr_pull_align(ndr, 4));
8178                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8179                 {
8180                         uint32_t _flags_save_string = ndr->flags;
8181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8182                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8183                         if (_ptr_driver_name) {
8184                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8185                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8186                         } else {
8187                                 r->driver_name = NULL;
8188                         }
8189                         ndr->flags = _flags_save_string;
8190                 }
8191                 {
8192                         uint32_t _flags_save_string = ndr->flags;
8193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8194                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8195                         if (_ptr_architecture) {
8196                                 NDR_PULL_ALLOC(ndr, r->architecture);
8197                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8198                         } else {
8199                                 r->architecture = NULL;
8200                         }
8201                         ndr->flags = _flags_save_string;
8202                 }
8203                 {
8204                         uint32_t _flags_save_string = ndr->flags;
8205                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8206                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8207                         if (_ptr_driver_path) {
8208                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8209                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8210                         } else {
8211                                 r->driver_path = NULL;
8212                         }
8213                         ndr->flags = _flags_save_string;
8214                 }
8215                 {
8216                         uint32_t _flags_save_string = ndr->flags;
8217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8218                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8219                         if (_ptr_data_file) {
8220                                 NDR_PULL_ALLOC(ndr, r->data_file);
8221                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8222                         } else {
8223                                 r->data_file = NULL;
8224                         }
8225                         ndr->flags = _flags_save_string;
8226                 }
8227                 {
8228                         uint32_t _flags_save_string = ndr->flags;
8229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8230                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8231                         if (_ptr_config_file) {
8232                                 NDR_PULL_ALLOC(ndr, r->config_file);
8233                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8234                         } else {
8235                                 r->config_file = NULL;
8236                         }
8237                         ndr->flags = _flags_save_string;
8238                 }
8239                 {
8240                         uint32_t _flags_save_string = ndr->flags;
8241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8242                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8243                         if (_ptr_help_file) {
8244                                 NDR_PULL_ALLOC(ndr, r->help_file);
8245                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
8246                         } else {
8247                                 r->help_file = NULL;
8248                         }
8249                         ndr->flags = _flags_save_string;
8250                 }
8251                 {
8252                         uint32_t _flags_save_string_array = ndr->flags;
8253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8254                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8255                         if (_ptr_dependent_files) {
8256                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
8257                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
8258                         } else {
8259                                 r->dependent_files = NULL;
8260                         }
8261                         ndr->flags = _flags_save_string_array;
8262                 }
8263                 {
8264                         uint32_t _flags_save_string = ndr->flags;
8265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8266                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8267                         if (_ptr_monitor_name) {
8268                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
8269                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
8270                         } else {
8271                                 r->monitor_name = NULL;
8272                         }
8273                         ndr->flags = _flags_save_string;
8274                 }
8275                 {
8276                         uint32_t _flags_save_string = ndr->flags;
8277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8278                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8279                         if (_ptr_default_datatype) {
8280                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
8281                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
8282                         } else {
8283                                 r->default_datatype = NULL;
8284                         }
8285                         ndr->flags = _flags_save_string;
8286                 }
8287                 {
8288                         uint32_t _flags_save_string_array = ndr->flags;
8289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8290                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8291                         if (_ptr_previous_names) {
8292                                 NDR_PULL_ALLOC(ndr, r->previous_names);
8293                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
8294                         } else {
8295                                 r->previous_names = NULL;
8296                         }
8297                         ndr->flags = _flags_save_string_array;
8298                 }
8299         }
8300         if (ndr_flags & NDR_BUFFERS) {
8301                 {
8302                         uint32_t _flags_save_string = ndr->flags;
8303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8304                         if (r->driver_name) {
8305                                 uint32_t _relative_save_offset;
8306                                 _relative_save_offset = ndr->offset;
8307                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8308                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8309                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8310                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8311                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8312                                 ndr->offset = _relative_save_offset;
8313                         }
8314                         ndr->flags = _flags_save_string;
8315                 }
8316                 {
8317                         uint32_t _flags_save_string = ndr->flags;
8318                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8319                         if (r->architecture) {
8320                                 uint32_t _relative_save_offset;
8321                                 _relative_save_offset = ndr->offset;
8322                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8323                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8324                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8325                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8326                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8327                                 ndr->offset = _relative_save_offset;
8328                         }
8329                         ndr->flags = _flags_save_string;
8330                 }
8331                 {
8332                         uint32_t _flags_save_string = ndr->flags;
8333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8334                         if (r->driver_path) {
8335                                 uint32_t _relative_save_offset;
8336                                 _relative_save_offset = ndr->offset;
8337                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8338                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8339                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8340                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8341                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8342                                 ndr->offset = _relative_save_offset;
8343                         }
8344                         ndr->flags = _flags_save_string;
8345                 }
8346                 {
8347                         uint32_t _flags_save_string = ndr->flags;
8348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8349                         if (r->data_file) {
8350                                 uint32_t _relative_save_offset;
8351                                 _relative_save_offset = ndr->offset;
8352                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8353                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8354                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8355                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8356                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8357                                 ndr->offset = _relative_save_offset;
8358                         }
8359                         ndr->flags = _flags_save_string;
8360                 }
8361                 {
8362                         uint32_t _flags_save_string = ndr->flags;
8363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8364                         if (r->config_file) {
8365                                 uint32_t _relative_save_offset;
8366                                 _relative_save_offset = ndr->offset;
8367                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8368                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8369                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8370                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8371                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8372                                 ndr->offset = _relative_save_offset;
8373                         }
8374                         ndr->flags = _flags_save_string;
8375                 }
8376                 {
8377                         uint32_t _flags_save_string = ndr->flags;
8378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8379                         if (r->help_file) {
8380                                 uint32_t _relative_save_offset;
8381                                 _relative_save_offset = ndr->offset;
8382                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
8383                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8384                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8385                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
8386                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8387                                 ndr->offset = _relative_save_offset;
8388                         }
8389                         ndr->flags = _flags_save_string;
8390                 }
8391                 {
8392                         uint32_t _flags_save_string_array = ndr->flags;
8393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8394                         if (r->dependent_files) {
8395                                 uint32_t _relative_save_offset;
8396                                 _relative_save_offset = ndr->offset;
8397                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
8398                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8399                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8400                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
8401                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8402                                 ndr->offset = _relative_save_offset;
8403                         }
8404                         ndr->flags = _flags_save_string_array;
8405                 }
8406                 {
8407                         uint32_t _flags_save_string = ndr->flags;
8408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8409                         if (r->monitor_name) {
8410                                 uint32_t _relative_save_offset;
8411                                 _relative_save_offset = ndr->offset;
8412                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
8413                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8414                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8415                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
8416                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8417                                 ndr->offset = _relative_save_offset;
8418                         }
8419                         ndr->flags = _flags_save_string;
8420                 }
8421                 {
8422                         uint32_t _flags_save_string = ndr->flags;
8423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8424                         if (r->default_datatype) {
8425                                 uint32_t _relative_save_offset;
8426                                 _relative_save_offset = ndr->offset;
8427                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
8428                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8429                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8430                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
8431                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8432                                 ndr->offset = _relative_save_offset;
8433                         }
8434                         ndr->flags = _flags_save_string;
8435                 }
8436                 {
8437                         uint32_t _flags_save_string_array = ndr->flags;
8438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8439                         if (r->previous_names) {
8440                                 uint32_t _relative_save_offset;
8441                                 _relative_save_offset = ndr->offset;
8442                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
8443                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8444                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8445                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
8446                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8447                                 ndr->offset = _relative_save_offset;
8448                         }
8449                         ndr->flags = _flags_save_string_array;
8450                 }
8451         }
8452         return NDR_ERR_SUCCESS;
8453 }
8454
8455 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
8456 {
8457         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
8458         ndr->depth++;
8459         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8460         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8461         ndr->depth++;
8462         if (r->driver_name) {
8463                 ndr_print_string(ndr, "driver_name", r->driver_name);
8464         }
8465         ndr->depth--;
8466         ndr_print_ptr(ndr, "architecture", r->architecture);
8467         ndr->depth++;
8468         if (r->architecture) {
8469                 ndr_print_string(ndr, "architecture", r->architecture);
8470         }
8471         ndr->depth--;
8472         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8473         ndr->depth++;
8474         if (r->driver_path) {
8475                 ndr_print_string(ndr, "driver_path", r->driver_path);
8476         }
8477         ndr->depth--;
8478         ndr_print_ptr(ndr, "data_file", r->data_file);
8479         ndr->depth++;
8480         if (r->data_file) {
8481                 ndr_print_string(ndr, "data_file", r->data_file);
8482         }
8483         ndr->depth--;
8484         ndr_print_ptr(ndr, "config_file", r->config_file);
8485         ndr->depth++;
8486         if (r->config_file) {
8487                 ndr_print_string(ndr, "config_file", r->config_file);
8488         }
8489         ndr->depth--;
8490         ndr_print_ptr(ndr, "help_file", r->help_file);
8491         ndr->depth++;
8492         if (r->help_file) {
8493                 ndr_print_string(ndr, "help_file", r->help_file);
8494         }
8495         ndr->depth--;
8496         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8497         ndr->depth++;
8498         if (r->dependent_files) {
8499                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
8500         }
8501         ndr->depth--;
8502         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8503         ndr->depth++;
8504         if (r->monitor_name) {
8505                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8506         }
8507         ndr->depth--;
8508         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8509         ndr->depth++;
8510         if (r->default_datatype) {
8511                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8512         }
8513         ndr->depth--;
8514         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8515         ndr->depth++;
8516         if (r->previous_names) {
8517                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
8518         }
8519         ndr->depth--;
8520         ndr->depth--;
8521 }
8522
8523 static enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
8524 {
8525         if (ndr_flags & NDR_SCALARS) {
8526                 NDR_CHECK(ndr_push_align(ndr, 4));
8527                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8528                 {
8529                         uint32_t _flags_save_string = ndr->flags;
8530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8532                         ndr->flags = _flags_save_string;
8533                 }
8534                 {
8535                         uint32_t _flags_save_string = ndr->flags;
8536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8538                         ndr->flags = _flags_save_string;
8539                 }
8540                 {
8541                         uint32_t _flags_save_string = ndr->flags;
8542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8544                         ndr->flags = _flags_save_string;
8545                 }
8546                 {
8547                         uint32_t _flags_save_string = ndr->flags;
8548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8550                         ndr->flags = _flags_save_string;
8551                 }
8552                 {
8553                         uint32_t _flags_save_string = ndr->flags;
8554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8556                         ndr->flags = _flags_save_string;
8557                 }
8558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
8559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
8560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
8561         }
8562         if (ndr_flags & NDR_BUFFERS) {
8563                 {
8564                         uint32_t _flags_save_string = ndr->flags;
8565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8566                         if (r->driver_name) {
8567                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8568                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8569                         }
8570                         ndr->flags = _flags_save_string;
8571                 }
8572                 {
8573                         uint32_t _flags_save_string = ndr->flags;
8574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8575                         if (r->architecture) {
8576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8578                         }
8579                         ndr->flags = _flags_save_string;
8580                 }
8581                 {
8582                         uint32_t _flags_save_string = ndr->flags;
8583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8584                         if (r->driver_path) {
8585                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8586                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8587                         }
8588                         ndr->flags = _flags_save_string;
8589                 }
8590                 {
8591                         uint32_t _flags_save_string = ndr->flags;
8592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8593                         if (r->data_file) {
8594                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8595                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8596                         }
8597                         ndr->flags = _flags_save_string;
8598                 }
8599                 {
8600                         uint32_t _flags_save_string = ndr->flags;
8601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8602                         if (r->config_file) {
8603                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8605                         }
8606                         ndr->flags = _flags_save_string;
8607                 }
8608         }
8609         return NDR_ERR_SUCCESS;
8610 }
8611
8612 static enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
8613 {
8614         uint32_t _ptr_driver_name;
8615         TALLOC_CTX *_mem_save_driver_name_0;
8616         uint32_t _ptr_architecture;
8617         TALLOC_CTX *_mem_save_architecture_0;
8618         uint32_t _ptr_driver_path;
8619         TALLOC_CTX *_mem_save_driver_path_0;
8620         uint32_t _ptr_data_file;
8621         TALLOC_CTX *_mem_save_data_file_0;
8622         uint32_t _ptr_config_file;
8623         TALLOC_CTX *_mem_save_config_file_0;
8624         if (ndr_flags & NDR_SCALARS) {
8625                 NDR_CHECK(ndr_pull_align(ndr, 4));
8626                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8627                 {
8628                         uint32_t _flags_save_string = ndr->flags;
8629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8630                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8631                         if (_ptr_driver_name) {
8632                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8633                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8634                         } else {
8635                                 r->driver_name = NULL;
8636                         }
8637                         ndr->flags = _flags_save_string;
8638                 }
8639                 {
8640                         uint32_t _flags_save_string = ndr->flags;
8641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8642                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8643                         if (_ptr_architecture) {
8644                                 NDR_PULL_ALLOC(ndr, r->architecture);
8645                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8646                         } else {
8647                                 r->architecture = NULL;
8648                         }
8649                         ndr->flags = _flags_save_string;
8650                 }
8651                 {
8652                         uint32_t _flags_save_string = ndr->flags;
8653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8654                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8655                         if (_ptr_driver_path) {
8656                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8657                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8658                         } else {
8659                                 r->driver_path = NULL;
8660                         }
8661                         ndr->flags = _flags_save_string;
8662                 }
8663                 {
8664                         uint32_t _flags_save_string = ndr->flags;
8665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8666                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8667                         if (_ptr_data_file) {
8668                                 NDR_PULL_ALLOC(ndr, r->data_file);
8669                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8670                         } else {
8671                                 r->data_file = NULL;
8672                         }
8673                         ndr->flags = _flags_save_string;
8674                 }
8675                 {
8676                         uint32_t _flags_save_string = ndr->flags;
8677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8678                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8679                         if (_ptr_config_file) {
8680                                 NDR_PULL_ALLOC(ndr, r->config_file);
8681                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8682                         } else {
8683                                 r->config_file = NULL;
8684                         }
8685                         ndr->flags = _flags_save_string;
8686                 }
8687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
8688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
8689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
8690         }
8691         if (ndr_flags & NDR_BUFFERS) {
8692                 {
8693                         uint32_t _flags_save_string = ndr->flags;
8694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8695                         if (r->driver_name) {
8696                                 uint32_t _relative_save_offset;
8697                                 _relative_save_offset = ndr->offset;
8698                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8699                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8700                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8701                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8702                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8703                                 ndr->offset = _relative_save_offset;
8704                         }
8705                         ndr->flags = _flags_save_string;
8706                 }
8707                 {
8708                         uint32_t _flags_save_string = ndr->flags;
8709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8710                         if (r->architecture) {
8711                                 uint32_t _relative_save_offset;
8712                                 _relative_save_offset = ndr->offset;
8713                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8714                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8715                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8716                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8717                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8718                                 ndr->offset = _relative_save_offset;
8719                         }
8720                         ndr->flags = _flags_save_string;
8721                 }
8722                 {
8723                         uint32_t _flags_save_string = ndr->flags;
8724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8725                         if (r->driver_path) {
8726                                 uint32_t _relative_save_offset;
8727                                 _relative_save_offset = ndr->offset;
8728                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8729                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8730                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8731                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8732                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8733                                 ndr->offset = _relative_save_offset;
8734                         }
8735                         ndr->flags = _flags_save_string;
8736                 }
8737                 {
8738                         uint32_t _flags_save_string = ndr->flags;
8739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8740                         if (r->data_file) {
8741                                 uint32_t _relative_save_offset;
8742                                 _relative_save_offset = ndr->offset;
8743                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8744                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8745                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8746                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8747                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8748                                 ndr->offset = _relative_save_offset;
8749                         }
8750                         ndr->flags = _flags_save_string;
8751                 }
8752                 {
8753                         uint32_t _flags_save_string = ndr->flags;
8754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8755                         if (r->config_file) {
8756                                 uint32_t _relative_save_offset;
8757                                 _relative_save_offset = ndr->offset;
8758                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8759                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8760                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8761                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8762                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8763                                 ndr->offset = _relative_save_offset;
8764                         }
8765                         ndr->flags = _flags_save_string;
8766                 }
8767         }
8768         return NDR_ERR_SUCCESS;
8769 }
8770
8771 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
8772 {
8773         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
8774         ndr->depth++;
8775         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8776         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8777         ndr->depth++;
8778         if (r->driver_name) {
8779                 ndr_print_string(ndr, "driver_name", r->driver_name);
8780         }
8781         ndr->depth--;
8782         ndr_print_ptr(ndr, "architecture", r->architecture);
8783         ndr->depth++;
8784         if (r->architecture) {
8785                 ndr_print_string(ndr, "architecture", r->architecture);
8786         }
8787         ndr->depth--;
8788         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8789         ndr->depth++;
8790         if (r->driver_path) {
8791                 ndr_print_string(ndr, "driver_path", r->driver_path);
8792         }
8793         ndr->depth--;
8794         ndr_print_ptr(ndr, "data_file", r->data_file);
8795         ndr->depth++;
8796         if (r->data_file) {
8797                 ndr_print_string(ndr, "data_file", r->data_file);
8798         }
8799         ndr->depth--;
8800         ndr_print_ptr(ndr, "config_file", r->config_file);
8801         ndr->depth++;
8802         if (r->config_file) {
8803                 ndr_print_string(ndr, "config_file", r->config_file);
8804         }
8805         ndr->depth--;
8806         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
8807         ndr_print_uint32(ndr, "config_version", r->config_version);
8808         ndr_print_uint32(ndr, "driver_version", r->driver_version);
8809         ndr->depth--;
8810 }
8811
8812 static enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
8813 {
8814         if (ndr_flags & NDR_SCALARS) {
8815                 NDR_CHECK(ndr_push_align(ndr, 8));
8816                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8817                 {
8818                         uint32_t _flags_save_string = ndr->flags;
8819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8820                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8821                         ndr->flags = _flags_save_string;
8822                 }
8823                 {
8824                         uint32_t _flags_save_string = ndr->flags;
8825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8826                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8827                         ndr->flags = _flags_save_string;
8828                 }
8829                 {
8830                         uint32_t _flags_save_string = ndr->flags;
8831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8832                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8833                         ndr->flags = _flags_save_string;
8834                 }
8835                 {
8836                         uint32_t _flags_save_string = ndr->flags;
8837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8838                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8839                         ndr->flags = _flags_save_string;
8840                 }
8841                 {
8842                         uint32_t _flags_save_string = ndr->flags;
8843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8844                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8845                         ndr->flags = _flags_save_string;
8846                 }
8847                 {
8848                         uint32_t _flags_save_string = ndr->flags;
8849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8850                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8851                         ndr->flags = _flags_save_string;
8852                 }
8853                 {
8854                         uint32_t _flags_save_string_array = ndr->flags;
8855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8856                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8857                         ndr->flags = _flags_save_string_array;
8858                 }
8859                 {
8860                         uint32_t _flags_save_string = ndr->flags;
8861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8862                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8863                         ndr->flags = _flags_save_string;
8864                 }
8865                 {
8866                         uint32_t _flags_save_string = ndr->flags;
8867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8868                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8869                         ndr->flags = _flags_save_string;
8870                 }
8871                 {
8872                         uint32_t _flags_save_string_array = ndr->flags;
8873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8874                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
8875                         ndr->flags = _flags_save_string_array;
8876                 }
8877                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
8878                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8879                 {
8880                         uint32_t _flags_save_string = ndr->flags;
8881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8882                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
8883                         ndr->flags = _flags_save_string;
8884                 }
8885                 {
8886                         uint32_t _flags_save_string = ndr->flags;
8887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8888                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
8889                         ndr->flags = _flags_save_string;
8890                 }
8891                 {
8892                         uint32_t _flags_save_string = ndr->flags;
8893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8894                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
8895                         ndr->flags = _flags_save_string;
8896                 }
8897                 {
8898                         uint32_t _flags_save_string = ndr->flags;
8899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8900                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
8901                         ndr->flags = _flags_save_string;
8902                 }
8903         }
8904         if (ndr_flags & NDR_BUFFERS) {
8905                 {
8906                         uint32_t _flags_save_string = ndr->flags;
8907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8908                         if (r->driver_name) {
8909                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8910                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8911                         }
8912                         ndr->flags = _flags_save_string;
8913                 }
8914                 {
8915                         uint32_t _flags_save_string = ndr->flags;
8916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8917                         if (r->architecture) {
8918                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8919                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8920                         }
8921                         ndr->flags = _flags_save_string;
8922                 }
8923                 {
8924                         uint32_t _flags_save_string = ndr->flags;
8925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8926                         if (r->driver_path) {
8927                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8928                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8929                         }
8930                         ndr->flags = _flags_save_string;
8931                 }
8932                 {
8933                         uint32_t _flags_save_string = ndr->flags;
8934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8935                         if (r->data_file) {
8936                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8937                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8938                         }
8939                         ndr->flags = _flags_save_string;
8940                 }
8941                 {
8942                         uint32_t _flags_save_string = ndr->flags;
8943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8944                         if (r->config_file) {
8945                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8946                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8947                         }
8948                         ndr->flags = _flags_save_string;
8949                 }
8950                 {
8951                         uint32_t _flags_save_string = ndr->flags;
8952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8953                         if (r->help_file) {
8954                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8955                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8956                         }
8957                         ndr->flags = _flags_save_string;
8958                 }
8959                 {
8960                         uint32_t _flags_save_string_array = ndr->flags;
8961                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8962                         if (r->dependent_files) {
8963                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8964                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8965                         }
8966                         ndr->flags = _flags_save_string_array;
8967                 }
8968                 {
8969                         uint32_t _flags_save_string = ndr->flags;
8970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8971                         if (r->monitor_name) {
8972                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8973                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8974                         }
8975                         ndr->flags = _flags_save_string;
8976                 }
8977                 {
8978                         uint32_t _flags_save_string = ndr->flags;
8979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8980                         if (r->default_datatype) {
8981                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8982                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8983                         }
8984                         ndr->flags = _flags_save_string;
8985                 }
8986                 {
8987                         uint32_t _flags_save_string_array = ndr->flags;
8988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8989                         if (r->previous_names) {
8990                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
8991                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
8992                         }
8993                         ndr->flags = _flags_save_string_array;
8994                 }
8995                 {
8996                         uint32_t _flags_save_string = ndr->flags;
8997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8998                         if (r->manufacturer_name) {
8999                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9000                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9001                         }
9002                         ndr->flags = _flags_save_string;
9003                 }
9004                 {
9005                         uint32_t _flags_save_string = ndr->flags;
9006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9007                         if (r->manufacturer_url) {
9008                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9009                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9010                         }
9011                         ndr->flags = _flags_save_string;
9012                 }
9013                 {
9014                         uint32_t _flags_save_string = ndr->flags;
9015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9016                         if (r->hardware_id) {
9017                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9018                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9019                         }
9020                         ndr->flags = _flags_save_string;
9021                 }
9022                 {
9023                         uint32_t _flags_save_string = ndr->flags;
9024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9025                         if (r->provider) {
9026                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9027                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9028                         }
9029                         ndr->flags = _flags_save_string;
9030                 }
9031         }
9032         return NDR_ERR_SUCCESS;
9033 }
9034
9035 static enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
9036 {
9037         uint32_t _ptr_driver_name;
9038         TALLOC_CTX *_mem_save_driver_name_0;
9039         uint32_t _ptr_architecture;
9040         TALLOC_CTX *_mem_save_architecture_0;
9041         uint32_t _ptr_driver_path;
9042         TALLOC_CTX *_mem_save_driver_path_0;
9043         uint32_t _ptr_data_file;
9044         TALLOC_CTX *_mem_save_data_file_0;
9045         uint32_t _ptr_config_file;
9046         TALLOC_CTX *_mem_save_config_file_0;
9047         uint32_t _ptr_help_file;
9048         TALLOC_CTX *_mem_save_help_file_0;
9049         uint32_t _ptr_dependent_files;
9050         TALLOC_CTX *_mem_save_dependent_files_0;
9051         uint32_t _ptr_monitor_name;
9052         TALLOC_CTX *_mem_save_monitor_name_0;
9053         uint32_t _ptr_default_datatype;
9054         TALLOC_CTX *_mem_save_default_datatype_0;
9055         uint32_t _ptr_previous_names;
9056         TALLOC_CTX *_mem_save_previous_names_0;
9057         uint32_t _ptr_manufacturer_name;
9058         TALLOC_CTX *_mem_save_manufacturer_name_0;
9059         uint32_t _ptr_manufacturer_url;
9060         TALLOC_CTX *_mem_save_manufacturer_url_0;
9061         uint32_t _ptr_hardware_id;
9062         TALLOC_CTX *_mem_save_hardware_id_0;
9063         uint32_t _ptr_provider;
9064         TALLOC_CTX *_mem_save_provider_0;
9065         if (ndr_flags & NDR_SCALARS) {
9066                 NDR_CHECK(ndr_pull_align(ndr, 8));
9067                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9068                 {
9069                         uint32_t _flags_save_string = ndr->flags;
9070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9071                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9072                         if (_ptr_driver_name) {
9073                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9074                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9075                         } else {
9076                                 r->driver_name = NULL;
9077                         }
9078                         ndr->flags = _flags_save_string;
9079                 }
9080                 {
9081                         uint32_t _flags_save_string = ndr->flags;
9082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9083                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9084                         if (_ptr_architecture) {
9085                                 NDR_PULL_ALLOC(ndr, r->architecture);
9086                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9087                         } else {
9088                                 r->architecture = NULL;
9089                         }
9090                         ndr->flags = _flags_save_string;
9091                 }
9092                 {
9093                         uint32_t _flags_save_string = ndr->flags;
9094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9095                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9096                         if (_ptr_driver_path) {
9097                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9098                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9099                         } else {
9100                                 r->driver_path = NULL;
9101                         }
9102                         ndr->flags = _flags_save_string;
9103                 }
9104                 {
9105                         uint32_t _flags_save_string = ndr->flags;
9106                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9107                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9108                         if (_ptr_data_file) {
9109                                 NDR_PULL_ALLOC(ndr, r->data_file);
9110                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9111                         } else {
9112                                 r->data_file = NULL;
9113                         }
9114                         ndr->flags = _flags_save_string;
9115                 }
9116                 {
9117                         uint32_t _flags_save_string = ndr->flags;
9118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9119                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9120                         if (_ptr_config_file) {
9121                                 NDR_PULL_ALLOC(ndr, r->config_file);
9122                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9123                         } else {
9124                                 r->config_file = NULL;
9125                         }
9126                         ndr->flags = _flags_save_string;
9127                 }
9128                 {
9129                         uint32_t _flags_save_string = ndr->flags;
9130                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9131                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9132                         if (_ptr_help_file) {
9133                                 NDR_PULL_ALLOC(ndr, r->help_file);
9134                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9135                         } else {
9136                                 r->help_file = NULL;
9137                         }
9138                         ndr->flags = _flags_save_string;
9139                 }
9140                 {
9141                         uint32_t _flags_save_string_array = ndr->flags;
9142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9143                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9144                         if (_ptr_dependent_files) {
9145                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9146                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9147                         } else {
9148                                 r->dependent_files = NULL;
9149                         }
9150                         ndr->flags = _flags_save_string_array;
9151                 }
9152                 {
9153                         uint32_t _flags_save_string = ndr->flags;
9154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9155                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9156                         if (_ptr_monitor_name) {
9157                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9158                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9159                         } else {
9160                                 r->monitor_name = NULL;
9161                         }
9162                         ndr->flags = _flags_save_string;
9163                 }
9164                 {
9165                         uint32_t _flags_save_string = ndr->flags;
9166                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9167                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9168                         if (_ptr_default_datatype) {
9169                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9170                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9171                         } else {
9172                                 r->default_datatype = NULL;
9173                         }
9174                         ndr->flags = _flags_save_string;
9175                 }
9176                 {
9177                         uint32_t _flags_save_string_array = ndr->flags;
9178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9179                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9180                         if (_ptr_previous_names) {
9181                                 NDR_PULL_ALLOC(ndr, r->previous_names);
9182                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
9183                         } else {
9184                                 r->previous_names = NULL;
9185                         }
9186                         ndr->flags = _flags_save_string_array;
9187                 }
9188                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
9189                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9190                 {
9191                         uint32_t _flags_save_string = ndr->flags;
9192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9193                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9194                         if (_ptr_manufacturer_name) {
9195                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9196                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
9197                         } else {
9198                                 r->manufacturer_name = NULL;
9199                         }
9200                         ndr->flags = _flags_save_string;
9201                 }
9202                 {
9203                         uint32_t _flags_save_string = ndr->flags;
9204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9205                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9206                         if (_ptr_manufacturer_url) {
9207                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9208                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
9209                         } else {
9210                                 r->manufacturer_url = NULL;
9211                         }
9212                         ndr->flags = _flags_save_string;
9213                 }
9214                 {
9215                         uint32_t _flags_save_string = ndr->flags;
9216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9217                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9218                         if (_ptr_hardware_id) {
9219                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
9220                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
9221                         } else {
9222                                 r->hardware_id = NULL;
9223                         }
9224                         ndr->flags = _flags_save_string;
9225                 }
9226                 {
9227                         uint32_t _flags_save_string = ndr->flags;
9228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9229                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9230                         if (_ptr_provider) {
9231                                 NDR_PULL_ALLOC(ndr, r->provider);
9232                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
9233                         } else {
9234                                 r->provider = NULL;
9235                         }
9236                         ndr->flags = _flags_save_string;
9237                 }
9238         }
9239         if (ndr_flags & NDR_BUFFERS) {
9240                 {
9241                         uint32_t _flags_save_string = ndr->flags;
9242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9243                         if (r->driver_name) {
9244                                 uint32_t _relative_save_offset;
9245                                 _relative_save_offset = ndr->offset;
9246                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9247                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9248                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9249                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9250                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9251                                 ndr->offset = _relative_save_offset;
9252                         }
9253                         ndr->flags = _flags_save_string;
9254                 }
9255                 {
9256                         uint32_t _flags_save_string = ndr->flags;
9257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9258                         if (r->architecture) {
9259                                 uint32_t _relative_save_offset;
9260                                 _relative_save_offset = ndr->offset;
9261                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
9262                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9263                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9264                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
9265                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9266                                 ndr->offset = _relative_save_offset;
9267                         }
9268                         ndr->flags = _flags_save_string;
9269                 }
9270                 {
9271                         uint32_t _flags_save_string = ndr->flags;
9272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9273                         if (r->driver_path) {
9274                                 uint32_t _relative_save_offset;
9275                                 _relative_save_offset = ndr->offset;
9276                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
9277                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9278                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9279                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
9280                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9281                                 ndr->offset = _relative_save_offset;
9282                         }
9283                         ndr->flags = _flags_save_string;
9284                 }
9285                 {
9286                         uint32_t _flags_save_string = ndr->flags;
9287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9288                         if (r->data_file) {
9289                                 uint32_t _relative_save_offset;
9290                                 _relative_save_offset = ndr->offset;
9291                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
9292                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9293                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9294                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
9295                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9296                                 ndr->offset = _relative_save_offset;
9297                         }
9298                         ndr->flags = _flags_save_string;
9299                 }
9300                 {
9301                         uint32_t _flags_save_string = ndr->flags;
9302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9303                         if (r->config_file) {
9304                                 uint32_t _relative_save_offset;
9305                                 _relative_save_offset = ndr->offset;
9306                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
9307                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9308                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9309                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
9310                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9311                                 ndr->offset = _relative_save_offset;
9312                         }
9313                         ndr->flags = _flags_save_string;
9314                 }
9315                 {
9316                         uint32_t _flags_save_string = ndr->flags;
9317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9318                         if (r->help_file) {
9319                                 uint32_t _relative_save_offset;
9320                                 _relative_save_offset = ndr->offset;
9321                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
9322                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9323                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9324                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
9325                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9326                                 ndr->offset = _relative_save_offset;
9327                         }
9328                         ndr->flags = _flags_save_string;
9329                 }
9330                 {
9331                         uint32_t _flags_save_string_array = ndr->flags;
9332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9333                         if (r->dependent_files) {
9334                                 uint32_t _relative_save_offset;
9335                                 _relative_save_offset = ndr->offset;
9336                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
9337                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9338                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9339                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
9340                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9341                                 ndr->offset = _relative_save_offset;
9342                         }
9343                         ndr->flags = _flags_save_string_array;
9344                 }
9345                 {
9346                         uint32_t _flags_save_string = ndr->flags;
9347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9348                         if (r->monitor_name) {
9349                                 uint32_t _relative_save_offset;
9350                                 _relative_save_offset = ndr->offset;
9351                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
9352                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9353                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9354                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
9355                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9356                                 ndr->offset = _relative_save_offset;
9357                         }
9358                         ndr->flags = _flags_save_string;
9359                 }
9360                 {
9361                         uint32_t _flags_save_string = ndr->flags;
9362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9363                         if (r->default_datatype) {
9364                                 uint32_t _relative_save_offset;
9365                                 _relative_save_offset = ndr->offset;
9366                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
9367                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9368                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9369                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
9370                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9371                                 ndr->offset = _relative_save_offset;
9372                         }
9373                         ndr->flags = _flags_save_string;
9374                 }
9375                 {
9376                         uint32_t _flags_save_string_array = ndr->flags;
9377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9378                         if (r->previous_names) {
9379                                 uint32_t _relative_save_offset;
9380                                 _relative_save_offset = ndr->offset;
9381                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
9382                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9383                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9384                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
9385                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9386                                 ndr->offset = _relative_save_offset;
9387                         }
9388                         ndr->flags = _flags_save_string_array;
9389                 }
9390                 {
9391                         uint32_t _flags_save_string = ndr->flags;
9392                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9393                         if (r->manufacturer_name) {
9394                                 uint32_t _relative_save_offset;
9395                                 _relative_save_offset = ndr->offset;
9396                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
9397                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9398                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9399                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
9400                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9401                                 ndr->offset = _relative_save_offset;
9402                         }
9403                         ndr->flags = _flags_save_string;
9404                 }
9405                 {
9406                         uint32_t _flags_save_string = ndr->flags;
9407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9408                         if (r->manufacturer_url) {
9409                                 uint32_t _relative_save_offset;
9410                                 _relative_save_offset = ndr->offset;
9411                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
9412                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9413                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9414                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
9415                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9416                                 ndr->offset = _relative_save_offset;
9417                         }
9418                         ndr->flags = _flags_save_string;
9419                 }
9420                 {
9421                         uint32_t _flags_save_string = ndr->flags;
9422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9423                         if (r->hardware_id) {
9424                                 uint32_t _relative_save_offset;
9425                                 _relative_save_offset = ndr->offset;
9426                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
9427                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9428                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9429                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
9430                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9431                                 ndr->offset = _relative_save_offset;
9432                         }
9433                         ndr->flags = _flags_save_string;
9434                 }
9435                 {
9436                         uint32_t _flags_save_string = ndr->flags;
9437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9438                         if (r->provider) {
9439                                 uint32_t _relative_save_offset;
9440                                 _relative_save_offset = ndr->offset;
9441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
9442                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9443                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
9445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9446                                 ndr->offset = _relative_save_offset;
9447                         }
9448                         ndr->flags = _flags_save_string;
9449                 }
9450         }
9451         return NDR_ERR_SUCCESS;
9452 }
9453
9454 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
9455 {
9456         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
9457         ndr->depth++;
9458         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9459         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9460         ndr->depth++;
9461         if (r->driver_name) {
9462                 ndr_print_string(ndr, "driver_name", r->driver_name);
9463         }
9464         ndr->depth--;
9465         ndr_print_ptr(ndr, "architecture", r->architecture);
9466         ndr->depth++;
9467         if (r->architecture) {
9468                 ndr_print_string(ndr, "architecture", r->architecture);
9469         }
9470         ndr->depth--;
9471         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9472         ndr->depth++;
9473         if (r->driver_path) {
9474                 ndr_print_string(ndr, "driver_path", r->driver_path);
9475         }
9476         ndr->depth--;
9477         ndr_print_ptr(ndr, "data_file", r->data_file);
9478         ndr->depth++;
9479         if (r->data_file) {
9480                 ndr_print_string(ndr, "data_file", r->data_file);
9481         }
9482         ndr->depth--;
9483         ndr_print_ptr(ndr, "config_file", r->config_file);
9484         ndr->depth++;
9485         if (r->config_file) {
9486                 ndr_print_string(ndr, "config_file", r->config_file);
9487         }
9488         ndr->depth--;
9489         ndr_print_ptr(ndr, "help_file", r->help_file);
9490         ndr->depth++;
9491         if (r->help_file) {
9492                 ndr_print_string(ndr, "help_file", r->help_file);
9493         }
9494         ndr->depth--;
9495         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9496         ndr->depth++;
9497         if (r->dependent_files) {
9498                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
9499         }
9500         ndr->depth--;
9501         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9502         ndr->depth++;
9503         if (r->monitor_name) {
9504                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9505         }
9506         ndr->depth--;
9507         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9508         ndr->depth++;
9509         if (r->default_datatype) {
9510                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9511         }
9512         ndr->depth--;
9513         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9514         ndr->depth++;
9515         if (r->previous_names) {
9516                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
9517         }
9518         ndr->depth--;
9519         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
9520         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9521         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9522         ndr->depth++;
9523         if (r->manufacturer_name) {
9524                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9525         }
9526         ndr->depth--;
9527         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9528         ndr->depth++;
9529         if (r->manufacturer_url) {
9530                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9531         }
9532         ndr->depth--;
9533         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9534         ndr->depth++;
9535         if (r->hardware_id) {
9536                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9537         }
9538         ndr->depth--;
9539         ndr_print_ptr(ndr, "provider", r->provider);
9540         ndr->depth++;
9541         if (r->provider) {
9542                 ndr_print_string(ndr, "provider", r->provider);
9543         }
9544         ndr->depth--;
9545         ndr->depth--;
9546 }
9547
9548 static enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
9549 {
9550         if (ndr_flags & NDR_SCALARS) {
9551                 NDR_CHECK(ndr_push_align(ndr, 8));
9552                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9553                 {
9554                         uint32_t _flags_save_string = ndr->flags;
9555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9556                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9557                         ndr->flags = _flags_save_string;
9558                 }
9559                 {
9560                         uint32_t _flags_save_string = ndr->flags;
9561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9562                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9563                         ndr->flags = _flags_save_string;
9564                 }
9565                 {
9566                         uint32_t _flags_save_string = ndr->flags;
9567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9568                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9569                         ndr->flags = _flags_save_string;
9570                 }
9571                 {
9572                         uint32_t _flags_save_string = ndr->flags;
9573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9574                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9575                         ndr->flags = _flags_save_string;
9576                 }
9577                 {
9578                         uint32_t _flags_save_string = ndr->flags;
9579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9580                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9581                         ndr->flags = _flags_save_string;
9582                 }
9583                 {
9584                         uint32_t _flags_save_string = ndr->flags;
9585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9586                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
9587                         ndr->flags = _flags_save_string;
9588                 }
9589                 {
9590                         uint32_t _flags_save_string = ndr->flags;
9591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9592                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
9593                         ndr->flags = _flags_save_string;
9594                 }
9595                 {
9596                         uint32_t _flags_save_string = ndr->flags;
9597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9598                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
9599                         ndr->flags = _flags_save_string;
9600                 }
9601                 {
9602                         uint32_t _flags_save_string_array = ndr->flags;
9603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9604                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
9605                         ndr->flags = _flags_save_string_array;
9606                 }
9607                 {
9608                         uint32_t _flags_save_string_array = ndr->flags;
9609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9610                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
9611                         ndr->flags = _flags_save_string_array;
9612                 }
9613                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
9614                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9615                 {
9616                         uint32_t _flags_save_string = ndr->flags;
9617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9618                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
9619                         ndr->flags = _flags_save_string;
9620                 }
9621                 {
9622                         uint32_t _flags_save_string = ndr->flags;
9623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9624                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
9625                         ndr->flags = _flags_save_string;
9626                 }
9627                 {
9628                         uint32_t _flags_save_string = ndr->flags;
9629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9630                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
9631                         ndr->flags = _flags_save_string;
9632                 }
9633                 {
9634                         uint32_t _flags_save_string = ndr->flags;
9635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9636                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
9637                         ndr->flags = _flags_save_string;
9638                 }
9639                 {
9640                         uint32_t _flags_save_string = ndr->flags;
9641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9642                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
9643                         ndr->flags = _flags_save_string;
9644                 }
9645                 {
9646                         uint32_t _flags_save_string = ndr->flags;
9647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9648                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
9649                         ndr->flags = _flags_save_string;
9650                 }
9651                 {
9652                         uint32_t _flags_save_string_array = ndr->flags;
9653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9654                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
9655                         ndr->flags = _flags_save_string_array;
9656                 }
9657                 {
9658                         uint32_t _flags_save_string = ndr->flags;
9659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9660                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
9661                         ndr->flags = _flags_save_string;
9662                 }
9663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9664                 {
9665                         uint32_t _flags_save_string_array = ndr->flags;
9666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9667                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
9668                         ndr->flags = _flags_save_string_array;
9669                 }
9670                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9671                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9672         }
9673         if (ndr_flags & NDR_BUFFERS) {
9674                 {
9675                         uint32_t _flags_save_string = ndr->flags;
9676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9677                         if (r->driver_name) {
9678                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9679                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9680                         }
9681                         ndr->flags = _flags_save_string;
9682                 }
9683                 {
9684                         uint32_t _flags_save_string = ndr->flags;
9685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9686                         if (r->architecture) {
9687                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9688                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9689                         }
9690                         ndr->flags = _flags_save_string;
9691                 }
9692                 {
9693                         uint32_t _flags_save_string = ndr->flags;
9694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9695                         if (r->driver_path) {
9696                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9697                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9698                         }
9699                         ndr->flags = _flags_save_string;
9700                 }
9701                 {
9702                         uint32_t _flags_save_string = ndr->flags;
9703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9704                         if (r->data_file) {
9705                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9706                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9707                         }
9708                         ndr->flags = _flags_save_string;
9709                 }
9710                 {
9711                         uint32_t _flags_save_string = ndr->flags;
9712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9713                         if (r->config_file) {
9714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9716                         }
9717                         ndr->flags = _flags_save_string;
9718                 }
9719                 {
9720                         uint32_t _flags_save_string = ndr->flags;
9721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9722                         if (r->help_file) {
9723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
9724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
9725                         }
9726                         ndr->flags = _flags_save_string;
9727                 }
9728                 {
9729                         uint32_t _flags_save_string = ndr->flags;
9730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9731                         if (r->monitor_name) {
9732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
9733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
9734                         }
9735                         ndr->flags = _flags_save_string;
9736                 }
9737                 {
9738                         uint32_t _flags_save_string = ndr->flags;
9739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9740                         if (r->default_datatype) {
9741                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
9742                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
9743                         }
9744                         ndr->flags = _flags_save_string;
9745                 }
9746                 {
9747                         uint32_t _flags_save_string_array = ndr->flags;
9748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9749                         if (r->dependent_files) {
9750                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
9751                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
9752                         }
9753                         ndr->flags = _flags_save_string_array;
9754                 }
9755                 {
9756                         uint32_t _flags_save_string_array = ndr->flags;
9757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9758                         if (r->previous_names) {
9759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
9760                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
9761                         }
9762                         ndr->flags = _flags_save_string_array;
9763                 }
9764                 {
9765                         uint32_t _flags_save_string = ndr->flags;
9766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9767                         if (r->manufacturer_name) {
9768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
9769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
9770                         }
9771                         ndr->flags = _flags_save_string;
9772                 }
9773                 {
9774                         uint32_t _flags_save_string = ndr->flags;
9775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9776                         if (r->manufacturer_url) {
9777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
9778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
9779                         }
9780                         ndr->flags = _flags_save_string;
9781                 }
9782                 {
9783                         uint32_t _flags_save_string = ndr->flags;
9784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9785                         if (r->hardware_id) {
9786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
9787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
9788                         }
9789                         ndr->flags = _flags_save_string;
9790                 }
9791                 {
9792                         uint32_t _flags_save_string = ndr->flags;
9793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9794                         if (r->provider) {
9795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
9796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
9797                         }
9798                         ndr->flags = _flags_save_string;
9799                 }
9800                 {
9801                         uint32_t _flags_save_string = ndr->flags;
9802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9803                         if (r->print_processor) {
9804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
9805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
9806                         }
9807                         ndr->flags = _flags_save_string;
9808                 }
9809                 {
9810                         uint32_t _flags_save_string = ndr->flags;
9811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9812                         if (r->vendor_setup) {
9813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
9814                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
9815                         }
9816                         ndr->flags = _flags_save_string;
9817                 }
9818                 {
9819                         uint32_t _flags_save_string_array = ndr->flags;
9820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9821                         if (r->color_profiles) {
9822                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
9823                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
9824                         }
9825                         ndr->flags = _flags_save_string_array;
9826                 }
9827                 {
9828                         uint32_t _flags_save_string = ndr->flags;
9829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9830                         if (r->inf_path) {
9831                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
9832                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
9833                         }
9834                         ndr->flags = _flags_save_string;
9835                 }
9836                 {
9837                         uint32_t _flags_save_string_array = ndr->flags;
9838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9839                         if (r->core_driver_dependencies) {
9840                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
9841                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
9842                         }
9843                         ndr->flags = _flags_save_string_array;
9844                 }
9845         }
9846         return NDR_ERR_SUCCESS;
9847 }
9848
9849 static enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
9850 {
9851         uint32_t _ptr_driver_name;
9852         TALLOC_CTX *_mem_save_driver_name_0;
9853         uint32_t _ptr_architecture;
9854         TALLOC_CTX *_mem_save_architecture_0;
9855         uint32_t _ptr_driver_path;
9856         TALLOC_CTX *_mem_save_driver_path_0;
9857         uint32_t _ptr_data_file;
9858         TALLOC_CTX *_mem_save_data_file_0;
9859         uint32_t _ptr_config_file;
9860         TALLOC_CTX *_mem_save_config_file_0;
9861         uint32_t _ptr_help_file;
9862         TALLOC_CTX *_mem_save_help_file_0;
9863         uint32_t _ptr_monitor_name;
9864         TALLOC_CTX *_mem_save_monitor_name_0;
9865         uint32_t _ptr_default_datatype;
9866         TALLOC_CTX *_mem_save_default_datatype_0;
9867         uint32_t _ptr_dependent_files;
9868         TALLOC_CTX *_mem_save_dependent_files_0;
9869         uint32_t _ptr_previous_names;
9870         TALLOC_CTX *_mem_save_previous_names_0;
9871         uint32_t _ptr_manufacturer_name;
9872         TALLOC_CTX *_mem_save_manufacturer_name_0;
9873         uint32_t _ptr_manufacturer_url;
9874         TALLOC_CTX *_mem_save_manufacturer_url_0;
9875         uint32_t _ptr_hardware_id;
9876         TALLOC_CTX *_mem_save_hardware_id_0;
9877         uint32_t _ptr_provider;
9878         TALLOC_CTX *_mem_save_provider_0;
9879         uint32_t _ptr_print_processor;
9880         TALLOC_CTX *_mem_save_print_processor_0;
9881         uint32_t _ptr_vendor_setup;
9882         TALLOC_CTX *_mem_save_vendor_setup_0;
9883         uint32_t _ptr_color_profiles;
9884         TALLOC_CTX *_mem_save_color_profiles_0;
9885         uint32_t _ptr_inf_path;
9886         TALLOC_CTX *_mem_save_inf_path_0;
9887         uint32_t _ptr_core_driver_dependencies;
9888         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9889         if (ndr_flags & NDR_SCALARS) {
9890                 NDR_CHECK(ndr_pull_align(ndr, 8));
9891                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9892                 {
9893                         uint32_t _flags_save_string = ndr->flags;
9894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9895                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9896                         if (_ptr_driver_name) {
9897                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9898                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9899                         } else {
9900                                 r->driver_name = NULL;
9901                         }
9902                         ndr->flags = _flags_save_string;
9903                 }
9904                 {
9905                         uint32_t _flags_save_string = ndr->flags;
9906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9908                         if (_ptr_architecture) {
9909                                 NDR_PULL_ALLOC(ndr, r->architecture);
9910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9911                         } else {
9912                                 r->architecture = NULL;
9913                         }
9914                         ndr->flags = _flags_save_string;
9915                 }
9916                 {
9917                         uint32_t _flags_save_string = ndr->flags;
9918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9919                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9920                         if (_ptr_driver_path) {
9921                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9922                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9923                         } else {
9924                                 r->driver_path = NULL;
9925                         }
9926                         ndr->flags = _flags_save_string;
9927                 }
9928                 {
9929                         uint32_t _flags_save_string = ndr->flags;
9930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9931                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9932                         if (_ptr_data_file) {
9933                                 NDR_PULL_ALLOC(ndr, r->data_file);
9934                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9935                         } else {
9936                                 r->data_file = NULL;
9937                         }
9938                         ndr->flags = _flags_save_string;
9939                 }
9940                 {
9941                         uint32_t _flags_save_string = ndr->flags;
9942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9943                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9944                         if (_ptr_config_file) {
9945                                 NDR_PULL_ALLOC(ndr, r->config_file);
9946                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9947                         } else {
9948                                 r->config_file = NULL;
9949                         }
9950                         ndr->flags = _flags_save_string;
9951                 }
9952                 {
9953                         uint32_t _flags_save_string = ndr->flags;
9954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9955                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9956                         if (_ptr_help_file) {
9957                                 NDR_PULL_ALLOC(ndr, r->help_file);
9958                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9959                         } else {
9960                                 r->help_file = NULL;
9961                         }
9962                         ndr->flags = _flags_save_string;
9963                 }
9964                 {
9965                         uint32_t _flags_save_string = ndr->flags;
9966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9967                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9968                         if (_ptr_monitor_name) {
9969                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9970                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9971                         } else {
9972                                 r->monitor_name = NULL;
9973                         }
9974                         ndr->flags = _flags_save_string;
9975                 }
9976                 {
9977                         uint32_t _flags_save_string = ndr->flags;
9978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9979                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9980                         if (_ptr_default_datatype) {
9981                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9982                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9983                         } else {
9984                                 r->default_datatype = NULL;
9985                         }
9986                         ndr->flags = _flags_save_string;
9987                 }
9988                 {
9989                         uint32_t _flags_save_string_array = ndr->flags;
9990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9991                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9992                         if (_ptr_dependent_files) {
9993                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9994                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9995                         } else {
9996                                 r->dependent_files = NULL;
9997                         }
9998                         ndr->flags = _flags_save_string_array;
9999                 }
10000                 {
10001                         uint32_t _flags_save_string_array = ndr->flags;
10002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10003                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10004                         if (_ptr_previous_names) {
10005                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10006                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10007                         } else {
10008                                 r->previous_names = NULL;
10009                         }
10010                         ndr->flags = _flags_save_string_array;
10011                 }
10012                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
10013                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10014                 {
10015                         uint32_t _flags_save_string = ndr->flags;
10016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10017                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10018                         if (_ptr_manufacturer_name) {
10019                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10020                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
10021                         } else {
10022                                 r->manufacturer_name = NULL;
10023                         }
10024                         ndr->flags = _flags_save_string;
10025                 }
10026                 {
10027                         uint32_t _flags_save_string = ndr->flags;
10028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10029                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10030                         if (_ptr_manufacturer_url) {
10031                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10032                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
10033                         } else {
10034                                 r->manufacturer_url = NULL;
10035                         }
10036                         ndr->flags = _flags_save_string;
10037                 }
10038                 {
10039                         uint32_t _flags_save_string = ndr->flags;
10040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10041                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10042                         if (_ptr_hardware_id) {
10043                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
10044                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
10045                         } else {
10046                                 r->hardware_id = NULL;
10047                         }
10048                         ndr->flags = _flags_save_string;
10049                 }
10050                 {
10051                         uint32_t _flags_save_string = ndr->flags;
10052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10053                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10054                         if (_ptr_provider) {
10055                                 NDR_PULL_ALLOC(ndr, r->provider);
10056                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
10057                         } else {
10058                                 r->provider = NULL;
10059                         }
10060                         ndr->flags = _flags_save_string;
10061                 }
10062                 {
10063                         uint32_t _flags_save_string = ndr->flags;
10064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10065                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10066                         if (_ptr_print_processor) {
10067                                 NDR_PULL_ALLOC(ndr, r->print_processor);
10068                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
10069                         } else {
10070                                 r->print_processor = NULL;
10071                         }
10072                         ndr->flags = _flags_save_string;
10073                 }
10074                 {
10075                         uint32_t _flags_save_string = ndr->flags;
10076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10077                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10078                         if (_ptr_vendor_setup) {
10079                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
10080                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
10081                         } else {
10082                                 r->vendor_setup = NULL;
10083                         }
10084                         ndr->flags = _flags_save_string;
10085                 }
10086                 {
10087                         uint32_t _flags_save_string_array = ndr->flags;
10088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10089                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10090                         if (_ptr_color_profiles) {
10091                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
10092                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
10093                         } else {
10094                                 r->color_profiles = NULL;
10095                         }
10096                         ndr->flags = _flags_save_string_array;
10097                 }
10098                 {
10099                         uint32_t _flags_save_string = ndr->flags;
10100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10101                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10102                         if (_ptr_inf_path) {
10103                                 NDR_PULL_ALLOC(ndr, r->inf_path);
10104                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
10105                         } else {
10106                                 r->inf_path = NULL;
10107                         }
10108                         ndr->flags = _flags_save_string;
10109                 }
10110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
10111                 {
10112                         uint32_t _flags_save_string_array = ndr->flags;
10113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10114                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
10115                         if (_ptr_core_driver_dependencies) {
10116                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10117                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
10118                         } else {
10119                                 r->core_driver_dependencies = NULL;
10120                         }
10121                         ndr->flags = _flags_save_string_array;
10122                 }
10123                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10124                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10125         }
10126         if (ndr_flags & NDR_BUFFERS) {
10127                 {
10128                         uint32_t _flags_save_string = ndr->flags;
10129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10130                         if (r->driver_name) {
10131                                 uint32_t _relative_save_offset;
10132                                 _relative_save_offset = ndr->offset;
10133                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10134                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10135                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10136                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10137                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10138                                 ndr->offset = _relative_save_offset;
10139                         }
10140                         ndr->flags = _flags_save_string;
10141                 }
10142                 {
10143                         uint32_t _flags_save_string = ndr->flags;
10144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10145                         if (r->architecture) {
10146                                 uint32_t _relative_save_offset;
10147                                 _relative_save_offset = ndr->offset;
10148                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10149                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10150                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10151                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10152                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10153                                 ndr->offset = _relative_save_offset;
10154                         }
10155                         ndr->flags = _flags_save_string;
10156                 }
10157                 {
10158                         uint32_t _flags_save_string = ndr->flags;
10159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10160                         if (r->driver_path) {
10161                                 uint32_t _relative_save_offset;
10162                                 _relative_save_offset = ndr->offset;
10163                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10164                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10165                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10166                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10167                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10168                                 ndr->offset = _relative_save_offset;
10169                         }
10170                         ndr->flags = _flags_save_string;
10171                 }
10172                 {
10173                         uint32_t _flags_save_string = ndr->flags;
10174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10175                         if (r->data_file) {
10176                                 uint32_t _relative_save_offset;
10177                                 _relative_save_offset = ndr->offset;
10178                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10179                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10180                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10181                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10182                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10183                                 ndr->offset = _relative_save_offset;
10184                         }
10185                         ndr->flags = _flags_save_string;
10186                 }
10187                 {
10188                         uint32_t _flags_save_string = ndr->flags;
10189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10190                         if (r->config_file) {
10191                                 uint32_t _relative_save_offset;
10192                                 _relative_save_offset = ndr->offset;
10193                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10194                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10195                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10196                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10197                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10198                                 ndr->offset = _relative_save_offset;
10199                         }
10200                         ndr->flags = _flags_save_string;
10201                 }
10202                 {
10203                         uint32_t _flags_save_string = ndr->flags;
10204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10205                         if (r->help_file) {
10206                                 uint32_t _relative_save_offset;
10207                                 _relative_save_offset = ndr->offset;
10208                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, 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_string(ndr, NDR_SCALARS, &r->help_file));
10212                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10213                                 ndr->offset = _relative_save_offset;
10214                         }
10215                         ndr->flags = _flags_save_string;
10216                 }
10217                 {
10218                         uint32_t _flags_save_string = ndr->flags;
10219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10220                         if (r->monitor_name) {
10221                                 uint32_t _relative_save_offset;
10222                                 _relative_save_offset = ndr->offset;
10223                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10224                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10225                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10226                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10227                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10228                                 ndr->offset = _relative_save_offset;
10229                         }
10230                         ndr->flags = _flags_save_string;
10231                 }
10232                 {
10233                         uint32_t _flags_save_string = ndr->flags;
10234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10235                         if (r->default_datatype) {
10236                                 uint32_t _relative_save_offset;
10237                                 _relative_save_offset = ndr->offset;
10238                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10239                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10240                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10241                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10242                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10243                                 ndr->offset = _relative_save_offset;
10244                         }
10245                         ndr->flags = _flags_save_string;
10246                 }
10247                 {
10248                         uint32_t _flags_save_string_array = ndr->flags;
10249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10250                         if (r->dependent_files) {
10251                                 uint32_t _relative_save_offset;
10252                                 _relative_save_offset = ndr->offset;
10253                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10254                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10255                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10256                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10257                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10258                                 ndr->offset = _relative_save_offset;
10259                         }
10260                         ndr->flags = _flags_save_string_array;
10261                 }
10262                 {
10263                         uint32_t _flags_save_string_array = ndr->flags;
10264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10265                         if (r->previous_names) {
10266                                 uint32_t _relative_save_offset;
10267                                 _relative_save_offset = ndr->offset;
10268                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
10269                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10270                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10271                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
10272                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10273                                 ndr->offset = _relative_save_offset;
10274                         }
10275                         ndr->flags = _flags_save_string_array;
10276                 }
10277                 {
10278                         uint32_t _flags_save_string = ndr->flags;
10279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10280                         if (r->manufacturer_name) {
10281                                 uint32_t _relative_save_offset;
10282                                 _relative_save_offset = ndr->offset;
10283                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
10284                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10285                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10286                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
10287                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10288                                 ndr->offset = _relative_save_offset;
10289                         }
10290                         ndr->flags = _flags_save_string;
10291                 }
10292                 {
10293                         uint32_t _flags_save_string = ndr->flags;
10294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10295                         if (r->manufacturer_url) {
10296                                 uint32_t _relative_save_offset;
10297                                 _relative_save_offset = ndr->offset;
10298                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
10299                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10300                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10301                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
10302                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10303                                 ndr->offset = _relative_save_offset;
10304                         }
10305                         ndr->flags = _flags_save_string;
10306                 }
10307                 {
10308                         uint32_t _flags_save_string = ndr->flags;
10309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10310                         if (r->hardware_id) {
10311                                 uint32_t _relative_save_offset;
10312                                 _relative_save_offset = ndr->offset;
10313                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
10314                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10315                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10316                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
10317                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10318                                 ndr->offset = _relative_save_offset;
10319                         }
10320                         ndr->flags = _flags_save_string;
10321                 }
10322                 {
10323                         uint32_t _flags_save_string = ndr->flags;
10324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10325                         if (r->provider) {
10326                                 uint32_t _relative_save_offset;
10327                                 _relative_save_offset = ndr->offset;
10328                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
10329                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10330                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10331                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
10332                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10333                                 ndr->offset = _relative_save_offset;
10334                         }
10335                         ndr->flags = _flags_save_string;
10336                 }
10337                 {
10338                         uint32_t _flags_save_string = ndr->flags;
10339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10340                         if (r->print_processor) {
10341                                 uint32_t _relative_save_offset;
10342                                 _relative_save_offset = ndr->offset;
10343                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
10344                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10345                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10346                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
10347                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10348                                 ndr->offset = _relative_save_offset;
10349                         }
10350                         ndr->flags = _flags_save_string;
10351                 }
10352                 {
10353                         uint32_t _flags_save_string = ndr->flags;
10354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10355                         if (r->vendor_setup) {
10356                                 uint32_t _relative_save_offset;
10357                                 _relative_save_offset = ndr->offset;
10358                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
10359                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10360                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10361                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
10362                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10363                                 ndr->offset = _relative_save_offset;
10364                         }
10365                         ndr->flags = _flags_save_string;
10366                 }
10367                 {
10368                         uint32_t _flags_save_string_array = ndr->flags;
10369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10370                         if (r->color_profiles) {
10371                                 uint32_t _relative_save_offset;
10372                                 _relative_save_offset = ndr->offset;
10373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
10374                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10375                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10376                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
10377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10378                                 ndr->offset = _relative_save_offset;
10379                         }
10380                         ndr->flags = _flags_save_string_array;
10381                 }
10382                 {
10383                         uint32_t _flags_save_string = ndr->flags;
10384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10385                         if (r->inf_path) {
10386                                 uint32_t _relative_save_offset;
10387                                 _relative_save_offset = ndr->offset;
10388                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
10389                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10390                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10391                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
10392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10393                                 ndr->offset = _relative_save_offset;
10394                         }
10395                         ndr->flags = _flags_save_string;
10396                 }
10397                 {
10398                         uint32_t _flags_save_string_array = ndr->flags;
10399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10400                         if (r->core_driver_dependencies) {
10401                                 uint32_t _relative_save_offset;
10402                                 _relative_save_offset = ndr->offset;
10403                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
10404                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10405                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10406                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
10407                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10408                                 ndr->offset = _relative_save_offset;
10409                         }
10410                         ndr->flags = _flags_save_string_array;
10411                 }
10412         }
10413         return NDR_ERR_SUCCESS;
10414 }
10415
10416 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
10417 {
10418         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
10419         ndr->depth++;
10420         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10421         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10422         ndr->depth++;
10423         if (r->driver_name) {
10424                 ndr_print_string(ndr, "driver_name", r->driver_name);
10425         }
10426         ndr->depth--;
10427         ndr_print_ptr(ndr, "architecture", r->architecture);
10428         ndr->depth++;
10429         if (r->architecture) {
10430                 ndr_print_string(ndr, "architecture", r->architecture);
10431         }
10432         ndr->depth--;
10433         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10434         ndr->depth++;
10435         if (r->driver_path) {
10436                 ndr_print_string(ndr, "driver_path", r->driver_path);
10437         }
10438         ndr->depth--;
10439         ndr_print_ptr(ndr, "data_file", r->data_file);
10440         ndr->depth++;
10441         if (r->data_file) {
10442                 ndr_print_string(ndr, "data_file", r->data_file);
10443         }
10444         ndr->depth--;
10445         ndr_print_ptr(ndr, "config_file", r->config_file);
10446         ndr->depth++;
10447         if (r->config_file) {
10448                 ndr_print_string(ndr, "config_file", r->config_file);
10449         }
10450         ndr->depth--;
10451         ndr_print_ptr(ndr, "help_file", r->help_file);
10452         ndr->depth++;
10453         if (r->help_file) {
10454                 ndr_print_string(ndr, "help_file", r->help_file);
10455         }
10456         ndr->depth--;
10457         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10458         ndr->depth++;
10459         if (r->monitor_name) {
10460                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10461         }
10462         ndr->depth--;
10463         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10464         ndr->depth++;
10465         if (r->default_datatype) {
10466                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10467         }
10468         ndr->depth--;
10469         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10470         ndr->depth++;
10471         if (r->dependent_files) {
10472                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10473         }
10474         ndr->depth--;
10475         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10476         ndr->depth++;
10477         if (r->previous_names) {
10478                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10479         }
10480         ndr->depth--;
10481         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
10482         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10483         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10484         ndr->depth++;
10485         if (r->manufacturer_name) {
10486                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10487         }
10488         ndr->depth--;
10489         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10490         ndr->depth++;
10491         if (r->manufacturer_url) {
10492                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10493         }
10494         ndr->depth--;
10495         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10496         ndr->depth++;
10497         if (r->hardware_id) {
10498                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10499         }
10500         ndr->depth--;
10501         ndr_print_ptr(ndr, "provider", r->provider);
10502         ndr->depth++;
10503         if (r->provider) {
10504                 ndr_print_string(ndr, "provider", r->provider);
10505         }
10506         ndr->depth--;
10507         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10508         ndr->depth++;
10509         if (r->print_processor) {
10510                 ndr_print_string(ndr, "print_processor", r->print_processor);
10511         }
10512         ndr->depth--;
10513         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10514         ndr->depth++;
10515         if (r->vendor_setup) {
10516                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10517         }
10518         ndr->depth--;
10519         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10520         ndr->depth++;
10521         if (r->color_profiles) {
10522                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
10523         }
10524         ndr->depth--;
10525         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10526         ndr->depth++;
10527         if (r->inf_path) {
10528                 ndr_print_string(ndr, "inf_path", r->inf_path);
10529         }
10530         ndr->depth--;
10531         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10532         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10533         ndr->depth++;
10534         if (r->core_driver_dependencies) {
10535                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10536         }
10537         ndr->depth--;
10538         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10539         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10540         ndr->depth--;
10541 }
10542
10543 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
10544 {
10545         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10546         if (ndr_flags & NDR_SCALARS) {
10547                 int level = ndr_push_get_switch_value(ndr, r);
10548                 switch (level) {
10549                         case 1: {
10550                                 NDR_CHECK(ndr_push_align(ndr, 4));
10551                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10552                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10553                         break; }
10554
10555                         case 2: {
10556                                 NDR_CHECK(ndr_push_align(ndr, 4));
10557                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10558                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10559                         break; }
10560
10561                         case 3: {
10562                                 NDR_CHECK(ndr_push_align(ndr, 4));
10563                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10564                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10565                         break; }
10566
10567                         case 4: {
10568                                 NDR_CHECK(ndr_push_align(ndr, 4));
10569                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10570                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10571                         break; }
10572
10573                         case 5: {
10574                                 NDR_CHECK(ndr_push_align(ndr, 4));
10575                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10576                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10577                         break; }
10578
10579                         case 6: {
10580                                 NDR_CHECK(ndr_push_align(ndr, 8));
10581                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10582                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10583                         break; }
10584
10585                         case 8: {
10586                                 NDR_CHECK(ndr_push_align(ndr, 8));
10587                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10588                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10589                         break; }
10590
10591                         default: {
10592                         break; }
10593
10594                 }
10595         }
10596         if (ndr_flags & NDR_BUFFERS) {
10597                 int level = ndr_push_get_switch_value(ndr, r);
10598                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10599                 switch (level) {
10600                         case 1:
10601                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10602                         break;
10603
10604                         case 2:
10605                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10606                         break;
10607
10608                         case 3:
10609                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10610                         break;
10611
10612                         case 4:
10613                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10614                         break;
10615
10616                         case 5:
10617                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10618                         break;
10619
10620                         case 6:
10621                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10622                         break;
10623
10624                         case 8:
10625                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10626                         break;
10627
10628                         default:
10629                         break;
10630
10631                 }
10632         }
10633         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10634         return NDR_ERR_SUCCESS;
10635 }
10636
10637 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
10638 {
10639         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10640         int level;
10641         level = ndr_pull_get_switch_value(ndr, r);
10642         if (ndr_flags & NDR_SCALARS) {
10643                 switch (level) {
10644                         case 1: {
10645                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10646                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10647                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
10648                         break; }
10649
10650                         case 2: {
10651                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10652                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10653                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
10654                         break; }
10655
10656                         case 3: {
10657                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10658                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10659                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
10660                         break; }
10661
10662                         case 4: {
10663                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10664                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10665                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
10666                         break; }
10667
10668                         case 5: {
10669                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10670                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10671                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
10672                         break; }
10673
10674                         case 6: {
10675                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10676                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10677                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
10678                         break; }
10679
10680                         case 8: {
10681                                 NDR_CHECK(ndr_pull_align(ndr, 8));
10682                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10683                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
10684                         break; }
10685
10686                         default: {
10687                         break; }
10688
10689                 }
10690         }
10691         if (ndr_flags & NDR_BUFFERS) {
10692                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10693                 switch (level) {
10694                         case 1:
10695                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
10696                         break;
10697
10698                         case 2:
10699                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
10700                         break;
10701
10702                         case 3:
10703                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
10704                         break;
10705
10706                         case 4:
10707                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
10708                         break;
10709
10710                         case 5:
10711                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
10712                         break;
10713
10714                         case 6:
10715                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
10716                         break;
10717
10718                         case 8:
10719                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
10720                         break;
10721
10722                         default:
10723                         break;
10724
10725                 }
10726         }
10727         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10728         return NDR_ERR_SUCCESS;
10729 }
10730
10731 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
10732 {
10733         int level;
10734         level = ndr_print_get_switch_value(ndr, r);
10735         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
10736         switch (level) {
10737                 case 1:
10738                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
10739                 break;
10740
10741                 case 2:
10742                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
10743                 break;
10744
10745                 case 3:
10746                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
10747                 break;
10748
10749                 case 4:
10750                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
10751                 break;
10752
10753                 case 5:
10754                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
10755                 break;
10756
10757                 case 6:
10758                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
10759                 break;
10760
10761                 case 8:
10762                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
10763                 break;
10764
10765                 default:
10766                 break;
10767
10768         }
10769 }
10770
10771 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
10772 {
10773         if (ndr_flags & NDR_SCALARS) {
10774                 NDR_CHECK(ndr_push_align(ndr, 4));
10775                 {
10776                         uint32_t _flags_save_string = ndr->flags;
10777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10778                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
10779                         ndr->flags = _flags_save_string;
10780                 }
10781         }
10782         if (ndr_flags & NDR_BUFFERS) {
10783         }
10784         return NDR_ERR_SUCCESS;
10785 }
10786
10787 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
10788 {
10789         if (ndr_flags & NDR_SCALARS) {
10790                 NDR_CHECK(ndr_pull_align(ndr, 4));
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
10795                         ndr->flags = _flags_save_string;
10796                 }
10797         }
10798         if (ndr_flags & NDR_BUFFERS) {
10799         }
10800         return NDR_ERR_SUCCESS;
10801 }
10802
10803 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
10804 {
10805         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
10806         ndr->depth++;
10807         ndr_print_string(ndr, "directory_name", r->directory_name);
10808         ndr->depth--;
10809 }
10810
10811 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10812 {
10813         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
10814 }
10815
10816 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
10817 {
10818         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10819         if (ndr_flags & NDR_SCALARS) {
10820                 int level = ndr_push_get_switch_value(ndr, r);
10821                 switch (level) {
10822                         case 1: {
10823                                 NDR_CHECK(ndr_push_align(ndr, 4));
10824                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10825                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10826                         break; }
10827
10828                         default: {
10829                                 NDR_CHECK(ndr_push_align(ndr, 4));
10830                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10831                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10832                         break; }
10833
10834                 }
10835         }
10836         if (ndr_flags & NDR_BUFFERS) {
10837                 int level = ndr_push_get_switch_value(ndr, r);
10838                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
10839                 switch (level) {
10840                         case 1:
10841                         break;
10842
10843                         default:
10844                         break;
10845
10846                 }
10847         }
10848         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
10849         return NDR_ERR_SUCCESS;
10850 }
10851
10852 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
10853 {
10854         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
10855         int level;
10856         level = ndr_pull_get_switch_value(ndr, r);
10857         if (ndr_flags & NDR_SCALARS) {
10858                 switch (level) {
10859                         case 1: {
10860                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10861                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10862                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10863                         break; }
10864
10865                         default: {
10866                                 NDR_CHECK(ndr_pull_align(ndr, 4));
10867                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
10868                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
10869                         break; }
10870
10871                 }
10872         }
10873         if (ndr_flags & NDR_BUFFERS) {
10874                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
10875                 switch (level) {
10876                         case 1:
10877                         break;
10878
10879                         default:
10880                         break;
10881
10882                 }
10883         }
10884         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
10885         return NDR_ERR_SUCCESS;
10886 }
10887
10888 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
10889 {
10890         int level;
10891         level = ndr_print_get_switch_value(ndr, r);
10892         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
10893         switch (level) {
10894                 case 1:
10895                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
10896                 break;
10897
10898                 default:
10899                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
10900                 break;
10901
10902         }
10903 }
10904
10905 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
10906 {
10907         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
10908 }
10909
10910 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
10911 {
10912         if (ndr_flags & NDR_SCALARS) {
10913                 NDR_CHECK(ndr_push_align(ndr, 4));
10914                 {
10915                         uint32_t _flags_save_string = ndr->flags;
10916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10917                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
10918                         ndr->flags = _flags_save_string;
10919                 }
10920         }
10921         if (ndr_flags & NDR_BUFFERS) {
10922                 {
10923                         uint32_t _flags_save_string = ndr->flags;
10924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10925                         if (r->print_processor_name) {
10926                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
10927                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
10928                         }
10929                         ndr->flags = _flags_save_string;
10930                 }
10931         }
10932         return NDR_ERR_SUCCESS;
10933 }
10934
10935 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
10936 {
10937         uint32_t _ptr_print_processor_name;
10938         TALLOC_CTX *_mem_save_print_processor_name_0;
10939         if (ndr_flags & NDR_SCALARS) {
10940                 NDR_CHECK(ndr_pull_align(ndr, 4));
10941                 {
10942                         uint32_t _flags_save_string = ndr->flags;
10943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10944                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
10945                         if (_ptr_print_processor_name) {
10946                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
10947                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
10948                         } else {
10949                                 r->print_processor_name = NULL;
10950                         }
10951                         ndr->flags = _flags_save_string;
10952                 }
10953         }
10954         if (ndr_flags & NDR_BUFFERS) {
10955                 {
10956                         uint32_t _flags_save_string = ndr->flags;
10957                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10958                         if (r->print_processor_name) {
10959                                 uint32_t _relative_save_offset;
10960                                 _relative_save_offset = ndr->offset;
10961                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
10962                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10963                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
10964                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
10965                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
10966                                 ndr->offset = _relative_save_offset;
10967                         }
10968                         ndr->flags = _flags_save_string;
10969                 }
10970         }
10971         return NDR_ERR_SUCCESS;
10972 }
10973
10974 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
10975 {
10976         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
10977         ndr->depth++;
10978         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
10979         ndr->depth++;
10980         if (r->print_processor_name) {
10981                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
10982         }
10983         ndr->depth--;
10984         ndr->depth--;
10985 }
10986
10987 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
10988 {
10989         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
10990         if (ndr_flags & NDR_SCALARS) {
10991                 int level = ndr_push_get_switch_value(ndr, r);
10992                 switch (level) {
10993                         case 1: {
10994                                 NDR_CHECK(ndr_push_align(ndr, 4));
10995                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
10996                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
10997                         break; }
10998
10999                         default: {
11000                         break; }
11001
11002                 }
11003         }
11004         if (ndr_flags & NDR_BUFFERS) {
11005                 int level = ndr_push_get_switch_value(ndr, r);
11006                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11007                 switch (level) {
11008                         case 1:
11009                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11010                         break;
11011
11012                         default:
11013                         break;
11014
11015                 }
11016         }
11017         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11018         return NDR_ERR_SUCCESS;
11019 }
11020
11021 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
11022 {
11023         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11024         int level;
11025         level = ndr_pull_get_switch_value(ndr, r);
11026         if (ndr_flags & NDR_SCALARS) {
11027                 switch (level) {
11028                         case 1: {
11029                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11030                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11031                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
11032                         break; }
11033
11034                         default: {
11035                         break; }
11036
11037                 }
11038         }
11039         if (ndr_flags & NDR_BUFFERS) {
11040                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11041                 switch (level) {
11042                         case 1:
11043                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
11044                         break;
11045
11046                         default:
11047                         break;
11048
11049                 }
11050         }
11051         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11052         return NDR_ERR_SUCCESS;
11053 }
11054
11055 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
11056 {
11057         int level;
11058         level = ndr_print_get_switch_value(ndr, r);
11059         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
11060         switch (level) {
11061                 case 1:
11062                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
11063                 break;
11064
11065                 default:
11066                 break;
11067
11068         }
11069 }
11070
11071 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
11072 {
11073         if (ndr_flags & NDR_SCALARS) {
11074                 NDR_CHECK(ndr_push_align(ndr, 4));
11075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
11076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
11077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
11078         }
11079         if (ndr_flags & NDR_BUFFERS) {
11080                 if (r->document_name) {
11081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
11084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11085                 }
11086                 if (r->output_file) {
11087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
11090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11091                 }
11092                 if (r->datatype) {
11093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
11096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11097                 }
11098         }
11099         return NDR_ERR_SUCCESS;
11100 }
11101
11102 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
11103 {
11104         uint32_t _ptr_document_name;
11105         TALLOC_CTX *_mem_save_document_name_0;
11106         uint32_t _ptr_output_file;
11107         TALLOC_CTX *_mem_save_output_file_0;
11108         uint32_t _ptr_datatype;
11109         TALLOC_CTX *_mem_save_datatype_0;
11110         if (ndr_flags & NDR_SCALARS) {
11111                 NDR_CHECK(ndr_pull_align(ndr, 4));
11112                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
11113                 if (_ptr_document_name) {
11114                         NDR_PULL_ALLOC(ndr, r->document_name);
11115                 } else {
11116                         r->document_name = NULL;
11117                 }
11118                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
11119                 if (_ptr_output_file) {
11120                         NDR_PULL_ALLOC(ndr, r->output_file);
11121                 } else {
11122                         r->output_file = NULL;
11123                 }
11124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
11125                 if (_ptr_datatype) {
11126                         NDR_PULL_ALLOC(ndr, r->datatype);
11127                 } else {
11128                         r->datatype = NULL;
11129                 }
11130         }
11131         if (ndr_flags & NDR_BUFFERS) {
11132                 if (r->document_name) {
11133                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11134                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
11135                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
11136                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
11137                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
11138                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
11139                         }
11140                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
11141                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
11142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
11143                 }
11144                 if (r->output_file) {
11145                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11146                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
11147                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
11148                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
11149                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
11150                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->output_file), ndr_get_array_length(ndr, &r->output_file));
11151                         }
11152                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
11153                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
11154                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
11155                 }
11156                 if (r->datatype) {
11157                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11158                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
11159                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
11160                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
11161                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
11162                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
11163                         }
11164                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
11165                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
11166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
11167                 }
11168         }
11169         return NDR_ERR_SUCCESS;
11170 }
11171
11172 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
11173 {
11174         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
11175         ndr->depth++;
11176         ndr_print_ptr(ndr, "document_name", r->document_name);
11177         ndr->depth++;
11178         if (r->document_name) {
11179                 ndr_print_string(ndr, "document_name", r->document_name);
11180         }
11181         ndr->depth--;
11182         ndr_print_ptr(ndr, "output_file", r->output_file);
11183         ndr->depth++;
11184         if (r->output_file) {
11185                 ndr_print_string(ndr, "output_file", r->output_file);
11186         }
11187         ndr->depth--;
11188         ndr_print_ptr(ndr, "datatype", r->datatype);
11189         ndr->depth++;
11190         if (r->datatype) {
11191                 ndr_print_string(ndr, "datatype", r->datatype);
11192         }
11193         ndr->depth--;
11194         ndr->depth--;
11195 }
11196
11197 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
11198 {
11199         if (ndr_flags & NDR_SCALARS) {
11200                 int level = ndr_push_get_switch_value(ndr, r);
11201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
11202                 switch (level) {
11203                         case 1: {
11204                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
11205                         break; }
11206
11207                         case 2: {
11208                         break; }
11209
11210                         case 3: {
11211                         break; }
11212
11213                         default: {
11214                         break; }
11215
11216                 }
11217         }
11218         if (ndr_flags & NDR_BUFFERS) {
11219                 int level = ndr_push_get_switch_value(ndr, r);
11220                 switch (level) {
11221                         case 1:
11222                                 if (r->info1) {
11223                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11224                                 }
11225                         break;
11226
11227                         case 2:
11228                         break;
11229
11230                         case 3:
11231                         break;
11232
11233                         default:
11234                         break;
11235
11236                 }
11237         }
11238         return NDR_ERR_SUCCESS;
11239 }
11240
11241 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
11242 {
11243         int level;
11244         uint32_t _level;
11245         TALLOC_CTX *_mem_save_info1_0;
11246         level = ndr_pull_get_switch_value(ndr, r);
11247         if (ndr_flags & NDR_SCALARS) {
11248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
11249                 if (_level != level) {
11250                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
11251                 }
11252                 switch (level) {
11253                         case 1: {
11254                                 uint32_t _ptr_info1;
11255                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
11256                                 if (_ptr_info1) {
11257                                         NDR_PULL_ALLOC(ndr, r->info1);
11258                                 } else {
11259                                         r->info1 = NULL;
11260                                 }
11261                         break; }
11262
11263                         case 2: {
11264                         break; }
11265
11266                         case 3: {
11267                         break; }
11268
11269                         default: {
11270                         break; }
11271
11272                 }
11273         }
11274         if (ndr_flags & NDR_BUFFERS) {
11275                 switch (level) {
11276                         case 1:
11277                                 if (r->info1) {
11278                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11279                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
11280                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
11281                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
11282                                 }
11283                         break;
11284
11285                         case 2:
11286                         break;
11287
11288                         case 3:
11289                         break;
11290
11291                         default:
11292                         break;
11293
11294                 }
11295         }
11296         return NDR_ERR_SUCCESS;
11297 }
11298
11299 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
11300 {
11301         int level;
11302         level = ndr_print_get_switch_value(ndr, r);
11303         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
11304         switch (level) {
11305                 case 1:
11306                         ndr_print_ptr(ndr, "info1", r->info1);
11307                         ndr->depth++;
11308                         if (r->info1) {
11309                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
11310                         }
11311                         ndr->depth--;
11312                 break;
11313
11314                 case 2:
11315                 break;
11316
11317                 case 3:
11318                 break;
11319
11320                 default:
11321                 break;
11322
11323         }
11324 }
11325
11326 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
11327 {
11328         if (ndr_flags & NDR_SCALARS) {
11329                 NDR_CHECK(ndr_push_align(ndr, 4));
11330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
11331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11335                 {
11336                         uint32_t _flags_save_string = ndr->flags;
11337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11338                         {
11339                                 struct ndr_push *_ndr_extra_string;
11340                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11341                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11342                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11343                         }
11344                         ndr->flags = _flags_save_string;
11345                 }
11346         }
11347         if (ndr_flags & NDR_BUFFERS) {
11348         }
11349         return NDR_ERR_SUCCESS;
11350 }
11351
11352 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
11353 {
11354         if (ndr_flags & NDR_SCALARS) {
11355                 NDR_CHECK(ndr_pull_align(ndr, 4));
11356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
11361                 {
11362                         uint32_t _flags_save_string = ndr->flags;
11363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11364                         {
11365                                 struct ndr_pull *_ndr_extra_string;
11366                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11367                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11368                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11369                         }
11370                         ndr->flags = _flags_save_string;
11371                 }
11372         }
11373         if (ndr_flags & NDR_BUFFERS) {
11374         }
11375         return NDR_ERR_SUCCESS;
11376 }
11377
11378 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
11379 {
11380         ndr_print_struct(ndr, name, "spoolss_OSVersion");
11381         ndr->depth++;
11382         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);
11383         ndr_print_uint32(ndr, "major", r->major);
11384         ndr_print_uint32(ndr, "minor", r->minor);
11385         ndr_print_uint32(ndr, "build", r->build);
11386         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
11387         ndr_print_string(ndr, "extra_string", r->extra_string);
11388         ndr->depth--;
11389 }
11390
11391 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
11392 {
11393         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
11394 }
11395
11396 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
11397 {
11398         if (ndr_flags & NDR_SCALARS) {
11399                 NDR_CHECK(ndr_push_align(ndr, 4));
11400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
11401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
11402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
11403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
11404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
11405                 {
11406                         uint32_t _flags_save_string = ndr->flags;
11407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11408                         {
11409                                 struct ndr_push *_ndr_extra_string;
11410                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11411                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
11412                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11413                         }
11414                         ndr->flags = _flags_save_string;
11415                 }
11416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
11417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
11418         }
11419         if (ndr_flags & NDR_BUFFERS) {
11420         }
11421         return NDR_ERR_SUCCESS;
11422 }
11423
11424 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
11425 {
11426         if (ndr_flags & NDR_SCALARS) {
11427                 NDR_CHECK(ndr_pull_align(ndr, 4));
11428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
11429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
11430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
11431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
11432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
11433                 {
11434                         uint32_t _flags_save_string = ndr->flags;
11435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11436                         {
11437                                 struct ndr_pull *_ndr_extra_string;
11438                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
11439                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
11440                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
11441                         }
11442                         ndr->flags = _flags_save_string;
11443                 }
11444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
11445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
11446         }
11447         if (ndr_flags & NDR_BUFFERS) {
11448         }
11449         return NDR_ERR_SUCCESS;
11450 }
11451
11452 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
11453 {
11454         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
11455         ndr->depth++;
11456         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);
11457         ndr_print_uint32(ndr, "major", r->major);
11458         ndr_print_uint32(ndr, "minor", r->minor);
11459         ndr_print_uint32(ndr, "build", r->build);
11460         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
11461         ndr_print_string(ndr, "extra_string", r->extra_string);
11462         ndr_print_uint32(ndr, "unknown2", r->unknown2);
11463         ndr_print_uint32(ndr, "unknown3", r->unknown3);
11464         ndr->depth--;
11465 }
11466
11467 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
11468 {
11469         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
11470 }
11471
11472 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
11473 {
11474         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11475         return NDR_ERR_SUCCESS;
11476 }
11477
11478 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
11479 {
11480         uint32_t v;
11481         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11482         *r = v;
11483         return NDR_ERR_SUCCESS;
11484 }
11485
11486 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
11487 {
11488         const char *val = NULL;
11489
11490         switch (r) {
11491                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
11492                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
11493                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
11494                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
11495                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
11496         }
11497         ndr_print_enum(ndr, name, "ENUM", val, r);
11498 }
11499
11500 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
11501 {
11502         if (ndr_flags & NDR_SCALARS) {
11503                 int level = ndr_push_get_switch_value(ndr, r);
11504                 switch (level) {
11505                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11506                         break; }
11507
11508                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11509                                 {
11510                                         uint32_t _flags_save_string = ndr->flags;
11511                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11512                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
11513                                         ndr->flags = _flags_save_string;
11514                                 }
11515                         break; }
11516
11517                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11518                                 {
11519                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11520                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11521                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11522                                         ndr->flags = _flags_save_DATA_BLOB;
11523                                 }
11524                         break; }
11525
11526                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11527                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
11528                         break; }
11529
11530                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11531                                 {
11532                                         uint32_t _flags_save_string_array = ndr->flags;
11533                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11534                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
11535                                         ndr->flags = _flags_save_string_array;
11536                                 }
11537                         break; }
11538
11539                         default: {
11540                                 {
11541                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11542                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11543                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
11544                                         ndr->flags = _flags_save_DATA_BLOB;
11545                                 }
11546                         break; }
11547
11548                 }
11549         }
11550         if (ndr_flags & NDR_BUFFERS) {
11551                 int level = ndr_push_get_switch_value(ndr, r);
11552                 switch (level) {
11553                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11554                         break;
11555
11556                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11557                         break;
11558
11559                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11560                         break;
11561
11562                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11563                         break;
11564
11565                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11566                         break;
11567
11568                         default:
11569                         break;
11570
11571                 }
11572         }
11573         return NDR_ERR_SUCCESS;
11574 }
11575
11576 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
11577 {
11578         int level;
11579         level = ndr_pull_get_switch_value(ndr, r);
11580         if (ndr_flags & NDR_SCALARS) {
11581                 switch (level) {
11582                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
11583                         break; }
11584
11585                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
11586                                 {
11587                                         uint32_t _flags_save_string = ndr->flags;
11588                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
11590                                         ndr->flags = _flags_save_string;
11591                                 }
11592                         break; }
11593
11594                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
11595                                 {
11596                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11597                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11598                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
11599                                         ndr->flags = _flags_save_DATA_BLOB;
11600                                 }
11601                         break; }
11602
11603                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
11604                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
11605                         break; }
11606
11607                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
11608                                 {
11609                                         uint32_t _flags_save_string_array = ndr->flags;
11610                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11611                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
11612                                         ndr->flags = _flags_save_string_array;
11613                                 }
11614                         break; }
11615
11616                         default: {
11617                                 {
11618                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
11619                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
11620                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
11621                                         ndr->flags = _flags_save_DATA_BLOB;
11622                                 }
11623                         break; }
11624
11625                 }
11626         }
11627         if (ndr_flags & NDR_BUFFERS) {
11628                 switch (level) {
11629                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11630                         break;
11631
11632                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11633                         break;
11634
11635                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11636                         break;
11637
11638                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11639                         break;
11640
11641                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11642                         break;
11643
11644                         default:
11645                         break;
11646
11647                 }
11648         }
11649         return NDR_ERR_SUCCESS;
11650 }
11651
11652 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
11653 {
11654         int level;
11655         level = ndr_print_get_switch_value(ndr, r);
11656         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
11657         switch (level) {
11658                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
11659                 break;
11660
11661                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
11662                         ndr_print_string(ndr, "string", r->string);
11663                 break;
11664
11665                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
11666                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
11667                 break;
11668
11669                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
11670                         ndr_print_uint32(ndr, "value", r->value);
11671                 break;
11672
11673                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
11674                         ndr_print_string_array(ndr, "string_array", r->string_array);
11675                 break;
11676
11677                 default:
11678                         ndr_print_DATA_BLOB(ndr, "data", r->data);
11679                 break;
11680
11681         }
11682 }
11683
11684 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11685 {
11686         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
11687 }
11688
11689 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
11690 {
11691         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11692         return NDR_ERR_SUCCESS;
11693 }
11694
11695 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
11696 {
11697         uint32_t v;
11698         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11699         *r = v;
11700         return NDR_ERR_SUCCESS;
11701 }
11702
11703 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
11704 {
11705         const char *val = NULL;
11706
11707         switch (r) {
11708                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
11709                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
11710                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
11711         }
11712         ndr_print_enum(ndr, name, "ENUM", val, r);
11713 }
11714
11715 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
11716 {
11717         if (ndr_flags & NDR_SCALARS) {
11718                 NDR_CHECK(ndr_push_align(ndr, 4));
11719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
11720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
11721         }
11722         if (ndr_flags & NDR_BUFFERS) {
11723         }
11724         return NDR_ERR_SUCCESS;
11725 }
11726
11727 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
11728 {
11729         if (ndr_flags & NDR_SCALARS) {
11730                 NDR_CHECK(ndr_pull_align(ndr, 4));
11731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
11732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
11733         }
11734         if (ndr_flags & NDR_BUFFERS) {
11735         }
11736         return NDR_ERR_SUCCESS;
11737 }
11738
11739 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
11740 {
11741         ndr_print_struct(ndr, name, "spoolss_FormSize");
11742         ndr->depth++;
11743         ndr_print_uint32(ndr, "width", r->width);
11744         ndr_print_uint32(ndr, "height", r->height);
11745         ndr->depth--;
11746 }
11747
11748 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
11749 {
11750         if (ndr_flags & NDR_SCALARS) {
11751                 NDR_CHECK(ndr_push_align(ndr, 4));
11752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
11753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
11754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
11755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
11756         }
11757         if (ndr_flags & NDR_BUFFERS) {
11758         }
11759         return NDR_ERR_SUCCESS;
11760 }
11761
11762 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
11763 {
11764         if (ndr_flags & NDR_SCALARS) {
11765                 NDR_CHECK(ndr_pull_align(ndr, 4));
11766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
11767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
11768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
11769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
11770         }
11771         if (ndr_flags & NDR_BUFFERS) {
11772         }
11773         return NDR_ERR_SUCCESS;
11774 }
11775
11776 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
11777 {
11778         ndr_print_struct(ndr, name, "spoolss_FormArea");
11779         ndr->depth++;
11780         ndr_print_uint32(ndr, "left", r->left);
11781         ndr_print_uint32(ndr, "top", r->top);
11782         ndr_print_uint32(ndr, "right", r->right);
11783         ndr_print_uint32(ndr, "bottom", r->bottom);
11784         ndr->depth--;
11785 }
11786
11787 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
11788 {
11789         if (ndr_flags & NDR_SCALARS) {
11790                 NDR_CHECK(ndr_push_align(ndr, 4));
11791                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
11792                 {
11793                         uint32_t _flags_save_string = ndr->flags;
11794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11795                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
11796                         ndr->flags = _flags_save_string;
11797                 }
11798                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11799                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11800         }
11801         if (ndr_flags & NDR_BUFFERS) {
11802                 {
11803                         uint32_t _flags_save_string = ndr->flags;
11804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11805                         if (r->form_name) {
11806                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
11807                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
11808                         }
11809                         ndr->flags = _flags_save_string;
11810                 }
11811         }
11812         return NDR_ERR_SUCCESS;
11813 }
11814
11815 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
11816 {
11817         uint32_t _ptr_form_name;
11818         TALLOC_CTX *_mem_save_form_name_0;
11819         if (ndr_flags & NDR_SCALARS) {
11820                 NDR_CHECK(ndr_pull_align(ndr, 4));
11821                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
11822                 {
11823                         uint32_t _flags_save_string = ndr->flags;
11824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11825                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
11826                         if (_ptr_form_name) {
11827                                 NDR_PULL_ALLOC(ndr, r->form_name);
11828                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
11829                         } else {
11830                                 r->form_name = NULL;
11831                         }
11832                         ndr->flags = _flags_save_string;
11833                 }
11834                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11835                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11836         }
11837         if (ndr_flags & NDR_BUFFERS) {
11838                 {
11839                         uint32_t _flags_save_string = ndr->flags;
11840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11841                         if (r->form_name) {
11842                                 uint32_t _relative_save_offset;
11843                                 _relative_save_offset = ndr->offset;
11844                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
11845                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11846                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
11847                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
11848                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
11849                                 ndr->offset = _relative_save_offset;
11850                         }
11851                         ndr->flags = _flags_save_string;
11852                 }
11853         }
11854         return NDR_ERR_SUCCESS;
11855 }
11856
11857 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
11858 {
11859         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
11860         ndr->depth++;
11861         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
11862         ndr_print_ptr(ndr, "form_name", r->form_name);
11863         ndr->depth++;
11864         if (r->form_name) {
11865                 ndr_print_string(ndr, "form_name", r->form_name);
11866         }
11867         ndr->depth--;
11868         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
11869         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
11870         ndr->depth--;
11871 }
11872
11873 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
11874 {
11875         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
11876         if (ndr_flags & NDR_SCALARS) {
11877                 int level = ndr_push_get_switch_value(ndr, r);
11878                 switch (level) {
11879                         case 1: {
11880                                 NDR_CHECK(ndr_push_align(ndr, 4));
11881                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
11882                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
11883                         break; }
11884
11885                         default: {
11886                         break; }
11887
11888                 }
11889         }
11890         if (ndr_flags & NDR_BUFFERS) {
11891                 int level = ndr_push_get_switch_value(ndr, r);
11892                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
11893                 switch (level) {
11894                         case 1:
11895                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
11896                         break;
11897
11898                         default:
11899                         break;
11900
11901                 }
11902         }
11903         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
11904         return NDR_ERR_SUCCESS;
11905 }
11906
11907 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
11908 {
11909         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
11910         int level;
11911         level = ndr_pull_get_switch_value(ndr, r);
11912         if (ndr_flags & NDR_SCALARS) {
11913                 switch (level) {
11914                         case 1: {
11915                                 NDR_CHECK(ndr_pull_align(ndr, 4));
11916                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
11917                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
11918                         break; }
11919
11920                         default: {
11921                         break; }
11922
11923                 }
11924         }
11925         if (ndr_flags & NDR_BUFFERS) {
11926                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
11927                 switch (level) {
11928                         case 1:
11929                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
11930                         break;
11931
11932                         default:
11933                         break;
11934
11935                 }
11936         }
11937         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
11938         return NDR_ERR_SUCCESS;
11939 }
11940
11941 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
11942 {
11943         int level;
11944         level = ndr_print_get_switch_value(ndr, r);
11945         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
11946         switch (level) {
11947                 case 1:
11948                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
11949                 break;
11950
11951                 default:
11952                 break;
11953
11954         }
11955 }
11956
11957 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
11958 {
11959         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
11960 }
11961
11962 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
11963 {
11964         if (ndr_flags & NDR_SCALARS) {
11965                 NDR_CHECK(ndr_push_align(ndr, 4));
11966                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
11967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
11968                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11969                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11970         }
11971         if (ndr_flags & NDR_BUFFERS) {
11972                 if (r->form_name) {
11973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
11974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
11976                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11977                 }
11978         }
11979         return NDR_ERR_SUCCESS;
11980 }
11981
11982 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
11983 {
11984         uint32_t _ptr_form_name;
11985         TALLOC_CTX *_mem_save_form_name_0;
11986         if (ndr_flags & NDR_SCALARS) {
11987                 NDR_CHECK(ndr_pull_align(ndr, 4));
11988                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
11989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
11990                 if (_ptr_form_name) {
11991                         NDR_PULL_ALLOC(ndr, r->form_name);
11992                 } else {
11993                         r->form_name = NULL;
11994                 }
11995                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
11996                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
11997         }
11998         if (ndr_flags & NDR_BUFFERS) {
11999                 if (r->form_name) {
12000                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12001                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
12002                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
12003                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
12004                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
12005                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
12006                         }
12007                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
12008                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
12009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
12010                 }
12011         }
12012         return NDR_ERR_SUCCESS;
12013 }
12014
12015 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
12016 {
12017         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
12018         ndr->depth++;
12019         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
12020         ndr_print_ptr(ndr, "form_name", r->form_name);
12021         ndr->depth++;
12022         if (r->form_name) {
12023                 ndr_print_string(ndr, "form_name", r->form_name);
12024         }
12025         ndr->depth--;
12026         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
12027         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
12028         ndr->depth--;
12029 }
12030
12031 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
12032 {
12033         if (ndr_flags & NDR_SCALARS) {
12034                 int level = ndr_push_get_switch_value(ndr, r);
12035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12036                 switch (level) {
12037                         case 1: {
12038                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
12039                         break; }
12040
12041                         default:
12042                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12043                 }
12044         }
12045         if (ndr_flags & NDR_BUFFERS) {
12046                 int level = ndr_push_get_switch_value(ndr, r);
12047                 switch (level) {
12048                         case 1:
12049                                 if (r->info1) {
12050                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12051                                 }
12052                         break;
12053
12054                         default:
12055                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12056                 }
12057         }
12058         return NDR_ERR_SUCCESS;
12059 }
12060
12061 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
12062 {
12063         int level;
12064         uint32_t _level;
12065         TALLOC_CTX *_mem_save_info1_0;
12066         level = ndr_pull_get_switch_value(ndr, r);
12067         if (ndr_flags & NDR_SCALARS) {
12068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12069                 if (_level != level) {
12070                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12071                 }
12072                 switch (level) {
12073                         case 1: {
12074                                 uint32_t _ptr_info1;
12075                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
12076                                 if (_ptr_info1) {
12077                                         NDR_PULL_ALLOC(ndr, r->info1);
12078                                 } else {
12079                                         r->info1 = NULL;
12080                                 }
12081                         break; }
12082
12083                         default:
12084                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12085                 }
12086         }
12087         if (ndr_flags & NDR_BUFFERS) {
12088                 switch (level) {
12089                         case 1:
12090                                 if (r->info1) {
12091                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12092                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
12093                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12094                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
12095                                 }
12096                         break;
12097
12098                         default:
12099                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
12100                 }
12101         }
12102         return NDR_ERR_SUCCESS;
12103 }
12104
12105 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
12106 {
12107         int level;
12108         level = ndr_print_get_switch_value(ndr, r);
12109         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
12110         switch (level) {
12111                 case 1:
12112                         ndr_print_ptr(ndr, "info1", r->info1);
12113                         ndr->depth++;
12114                         if (r->info1) {
12115                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
12116                         }
12117                         ndr->depth--;
12118                 break;
12119
12120                 default:
12121                         ndr_print_bad_level(ndr, name, level);
12122         }
12123 }
12124
12125 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
12126 {
12127         if (ndr_flags & NDR_SCALARS) {
12128                 NDR_CHECK(ndr_push_align(ndr, 4));
12129                 {
12130                         uint32_t _flags_save_string = ndr->flags;
12131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12132                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12133                         ndr->flags = _flags_save_string;
12134                 }
12135         }
12136         if (ndr_flags & NDR_BUFFERS) {
12137                 {
12138                         uint32_t _flags_save_string = ndr->flags;
12139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12140                         if (r->port_name) {
12141                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12142                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12143                         }
12144                         ndr->flags = _flags_save_string;
12145                 }
12146         }
12147         return NDR_ERR_SUCCESS;
12148 }
12149
12150 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
12151 {
12152         uint32_t _ptr_port_name;
12153         TALLOC_CTX *_mem_save_port_name_0;
12154         if (ndr_flags & NDR_SCALARS) {
12155                 NDR_CHECK(ndr_pull_align(ndr, 4));
12156                 {
12157                         uint32_t _flags_save_string = ndr->flags;
12158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12159                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12160                         if (_ptr_port_name) {
12161                                 NDR_PULL_ALLOC(ndr, r->port_name);
12162                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12163                         } else {
12164                                 r->port_name = NULL;
12165                         }
12166                         ndr->flags = _flags_save_string;
12167                 }
12168         }
12169         if (ndr_flags & NDR_BUFFERS) {
12170                 {
12171                         uint32_t _flags_save_string = ndr->flags;
12172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12173                         if (r->port_name) {
12174                                 uint32_t _relative_save_offset;
12175                                 _relative_save_offset = ndr->offset;
12176                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12177                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12178                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12179                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12180                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12181                                 ndr->offset = _relative_save_offset;
12182                         }
12183                         ndr->flags = _flags_save_string;
12184                 }
12185         }
12186         return NDR_ERR_SUCCESS;
12187 }
12188
12189 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
12190 {
12191         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
12192         ndr->depth++;
12193         ndr_print_ptr(ndr, "port_name", r->port_name);
12194         ndr->depth++;
12195         if (r->port_name) {
12196                 ndr_print_string(ndr, "port_name", r->port_name);
12197         }
12198         ndr->depth--;
12199         ndr->depth--;
12200 }
12201
12202 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12203 {
12204         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12205         return NDR_ERR_SUCCESS;
12206 }
12207
12208 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12209 {
12210         uint32_t v;
12211         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12212         *r = v;
12213         return NDR_ERR_SUCCESS;
12214 }
12215
12216 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
12217 {
12218         ndr_print_uint32(ndr, name, r);
12219         ndr->depth++;
12220         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
12221         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
12222         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
12223         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
12224         ndr->depth--;
12225 }
12226
12227 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
12228 {
12229         if (ndr_flags & NDR_SCALARS) {
12230                 NDR_CHECK(ndr_push_align(ndr, 4));
12231                 {
12232                         uint32_t _flags_save_string = ndr->flags;
12233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
12235                         ndr->flags = _flags_save_string;
12236                 }
12237                 {
12238                         uint32_t _flags_save_string = ndr->flags;
12239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12241                         ndr->flags = _flags_save_string;
12242                 }
12243                 {
12244                         uint32_t _flags_save_string = ndr->flags;
12245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12246                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
12247                         ndr->flags = _flags_save_string;
12248                 }
12249                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
12250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12251         }
12252         if (ndr_flags & NDR_BUFFERS) {
12253                 {
12254                         uint32_t _flags_save_string = ndr->flags;
12255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12256                         if (r->port_name) {
12257                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
12258                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
12259                         }
12260                         ndr->flags = _flags_save_string;
12261                 }
12262                 {
12263                         uint32_t _flags_save_string = ndr->flags;
12264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12265                         if (r->monitor_name) {
12266                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12267                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12268                         }
12269                         ndr->flags = _flags_save_string;
12270                 }
12271                 {
12272                         uint32_t _flags_save_string = ndr->flags;
12273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12274                         if (r->description) {
12275                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
12276                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
12277                         }
12278                         ndr->flags = _flags_save_string;
12279                 }
12280         }
12281         return NDR_ERR_SUCCESS;
12282 }
12283
12284 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
12285 {
12286         uint32_t _ptr_port_name;
12287         TALLOC_CTX *_mem_save_port_name_0;
12288         uint32_t _ptr_monitor_name;
12289         TALLOC_CTX *_mem_save_monitor_name_0;
12290         uint32_t _ptr_description;
12291         TALLOC_CTX *_mem_save_description_0;
12292         if (ndr_flags & NDR_SCALARS) {
12293                 NDR_CHECK(ndr_pull_align(ndr, 4));
12294                 {
12295                         uint32_t _flags_save_string = ndr->flags;
12296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12297                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
12298                         if (_ptr_port_name) {
12299                                 NDR_PULL_ALLOC(ndr, r->port_name);
12300                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
12301                         } else {
12302                                 r->port_name = NULL;
12303                         }
12304                         ndr->flags = _flags_save_string;
12305                 }
12306                 {
12307                         uint32_t _flags_save_string = ndr->flags;
12308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12309                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12310                         if (_ptr_monitor_name) {
12311                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12312                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12313                         } else {
12314                                 r->monitor_name = NULL;
12315                         }
12316                         ndr->flags = _flags_save_string;
12317                 }
12318                 {
12319                         uint32_t _flags_save_string = ndr->flags;
12320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12321                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
12322                         if (_ptr_description) {
12323                                 NDR_PULL_ALLOC(ndr, r->description);
12324                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
12325                         } else {
12326                                 r->description = NULL;
12327                         }
12328                         ndr->flags = _flags_save_string;
12329                 }
12330                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
12331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12332         }
12333         if (ndr_flags & NDR_BUFFERS) {
12334                 {
12335                         uint32_t _flags_save_string = ndr->flags;
12336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12337                         if (r->port_name) {
12338                                 uint32_t _relative_save_offset;
12339                                 _relative_save_offset = ndr->offset;
12340                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
12341                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12342                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
12343                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
12344                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
12345                                 ndr->offset = _relative_save_offset;
12346                         }
12347                         ndr->flags = _flags_save_string;
12348                 }
12349                 {
12350                         uint32_t _flags_save_string = ndr->flags;
12351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12352                         if (r->monitor_name) {
12353                                 uint32_t _relative_save_offset;
12354                                 _relative_save_offset = ndr->offset;
12355                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12356                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12357                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12358                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12359                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12360                                 ndr->offset = _relative_save_offset;
12361                         }
12362                         ndr->flags = _flags_save_string;
12363                 }
12364                 {
12365                         uint32_t _flags_save_string = ndr->flags;
12366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12367                         if (r->description) {
12368                                 uint32_t _relative_save_offset;
12369                                 _relative_save_offset = ndr->offset;
12370                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
12371                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
12372                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
12373                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
12374                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
12375                                 ndr->offset = _relative_save_offset;
12376                         }
12377                         ndr->flags = _flags_save_string;
12378                 }
12379         }
12380         return NDR_ERR_SUCCESS;
12381 }
12382
12383 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
12384 {
12385         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
12386         ndr->depth++;
12387         ndr_print_ptr(ndr, "port_name", r->port_name);
12388         ndr->depth++;
12389         if (r->port_name) {
12390                 ndr_print_string(ndr, "port_name", r->port_name);
12391         }
12392         ndr->depth--;
12393         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12394         ndr->depth++;
12395         if (r->monitor_name) {
12396                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12397         }
12398         ndr->depth--;
12399         ndr_print_ptr(ndr, "description", r->description);
12400         ndr->depth++;
12401         if (r->description) {
12402                 ndr_print_string(ndr, "description", r->description);
12403         }
12404         ndr->depth--;
12405         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
12406         ndr_print_uint32(ndr, "reserved", r->reserved);
12407         ndr->depth--;
12408 }
12409
12410 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
12411 {
12412         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12413         if (ndr_flags & NDR_SCALARS) {
12414                 int level = ndr_push_get_switch_value(ndr, r);
12415                 switch (level) {
12416                         case 1: {
12417                                 NDR_CHECK(ndr_push_align(ndr, 4));
12418                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12419                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12420                         break; }
12421
12422                         case 2: {
12423                                 NDR_CHECK(ndr_push_align(ndr, 4));
12424                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12425                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12426                         break; }
12427
12428                         case 3: {
12429                         break; }
12430
12431                         default: {
12432                         break; }
12433
12434                 }
12435         }
12436         if (ndr_flags & NDR_BUFFERS) {
12437                 int level = ndr_push_get_switch_value(ndr, r);
12438                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12439                 switch (level) {
12440                         case 1:
12441                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12442                         break;
12443
12444                         case 2:
12445                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12446                         break;
12447
12448                         case 3:
12449                         break;
12450
12451                         default:
12452                         break;
12453
12454                 }
12455         }
12456         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12457         return NDR_ERR_SUCCESS;
12458 }
12459
12460 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
12461 {
12462         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12463         int level;
12464         level = ndr_pull_get_switch_value(ndr, r);
12465         if (ndr_flags & NDR_SCALARS) {
12466                 switch (level) {
12467                         case 1: {
12468                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12469                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12470                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
12471                         break; }
12472
12473                         case 2: {
12474                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12475                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12476                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
12477                         break; }
12478
12479                         case 3: {
12480                         break; }
12481
12482                         default: {
12483                         break; }
12484
12485                 }
12486         }
12487         if (ndr_flags & NDR_BUFFERS) {
12488                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12489                 switch (level) {
12490                         case 1:
12491                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
12492                         break;
12493
12494                         case 2:
12495                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
12496                         break;
12497
12498                         case 3:
12499                         break;
12500
12501                         default:
12502                         break;
12503
12504                 }
12505         }
12506         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12507         return NDR_ERR_SUCCESS;
12508 }
12509
12510 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
12511 {
12512         int level;
12513         level = ndr_print_get_switch_value(ndr, r);
12514         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
12515         switch (level) {
12516                 case 1:
12517                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
12518                 break;
12519
12520                 case 2:
12521                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
12522                 break;
12523
12524                 case 3:
12525                 break;
12526
12527                 default:
12528                 break;
12529
12530         }
12531 }
12532
12533 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
12534 {
12535         if (ndr_flags & NDR_SCALARS) {
12536                 NDR_CHECK(ndr_push_align(ndr, 4));
12537                 {
12538                         uint32_t _flags_save_string = ndr->flags;
12539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12540                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12541                         ndr->flags = _flags_save_string;
12542                 }
12543         }
12544         if (ndr_flags & NDR_BUFFERS) {
12545                 {
12546                         uint32_t _flags_save_string = ndr->flags;
12547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12548                         if (r->monitor_name) {
12549                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12550                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12551                         }
12552                         ndr->flags = _flags_save_string;
12553                 }
12554         }
12555         return NDR_ERR_SUCCESS;
12556 }
12557
12558 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
12559 {
12560         uint32_t _ptr_monitor_name;
12561         TALLOC_CTX *_mem_save_monitor_name_0;
12562         if (ndr_flags & NDR_SCALARS) {
12563                 NDR_CHECK(ndr_pull_align(ndr, 4));
12564                 {
12565                         uint32_t _flags_save_string = ndr->flags;
12566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12567                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12568                         if (_ptr_monitor_name) {
12569                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12570                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12571                         } else {
12572                                 r->monitor_name = NULL;
12573                         }
12574                         ndr->flags = _flags_save_string;
12575                 }
12576         }
12577         if (ndr_flags & NDR_BUFFERS) {
12578                 {
12579                         uint32_t _flags_save_string = ndr->flags;
12580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12581                         if (r->monitor_name) {
12582                                 uint32_t _relative_save_offset;
12583                                 _relative_save_offset = ndr->offset;
12584                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12585                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12586                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12587                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12588                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12589                                 ndr->offset = _relative_save_offset;
12590                         }
12591                         ndr->flags = _flags_save_string;
12592                 }
12593         }
12594         return NDR_ERR_SUCCESS;
12595 }
12596
12597 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
12598 {
12599         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
12600         ndr->depth++;
12601         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12602         ndr->depth++;
12603         if (r->monitor_name) {
12604                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12605         }
12606         ndr->depth--;
12607         ndr->depth--;
12608 }
12609
12610 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
12611 {
12612         if (ndr_flags & NDR_SCALARS) {
12613                 NDR_CHECK(ndr_push_align(ndr, 4));
12614                 {
12615                         uint32_t _flags_save_string = ndr->flags;
12616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12617                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12618                         ndr->flags = _flags_save_string;
12619                 }
12620                 {
12621                         uint32_t _flags_save_string = ndr->flags;
12622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12623                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
12624                         ndr->flags = _flags_save_string;
12625                 }
12626                 {
12627                         uint32_t _flags_save_string = ndr->flags;
12628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12629                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
12630                         ndr->flags = _flags_save_string;
12631                 }
12632         }
12633         if (ndr_flags & NDR_BUFFERS) {
12634                 {
12635                         uint32_t _flags_save_string = ndr->flags;
12636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12637                         if (r->monitor_name) {
12638                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12639                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12640                         }
12641                         ndr->flags = _flags_save_string;
12642                 }
12643                 {
12644                         uint32_t _flags_save_string = ndr->flags;
12645                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12646                         if (r->environment) {
12647                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
12648                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
12649                         }
12650                         ndr->flags = _flags_save_string;
12651                 }
12652                 {
12653                         uint32_t _flags_save_string = ndr->flags;
12654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12655                         if (r->dll_name) {
12656                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
12657                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
12658                         }
12659                         ndr->flags = _flags_save_string;
12660                 }
12661         }
12662         return NDR_ERR_SUCCESS;
12663 }
12664
12665 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
12666 {
12667         uint32_t _ptr_monitor_name;
12668         TALLOC_CTX *_mem_save_monitor_name_0;
12669         uint32_t _ptr_environment;
12670         TALLOC_CTX *_mem_save_environment_0;
12671         uint32_t _ptr_dll_name;
12672         TALLOC_CTX *_mem_save_dll_name_0;
12673         if (ndr_flags & NDR_SCALARS) {
12674                 NDR_CHECK(ndr_pull_align(ndr, 4));
12675                 {
12676                         uint32_t _flags_save_string = ndr->flags;
12677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12678                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12679                         if (_ptr_monitor_name) {
12680                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12681                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12682                         } else {
12683                                 r->monitor_name = NULL;
12684                         }
12685                         ndr->flags = _flags_save_string;
12686                 }
12687                 {
12688                         uint32_t _flags_save_string = ndr->flags;
12689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12690                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
12691                         if (_ptr_environment) {
12692                                 NDR_PULL_ALLOC(ndr, r->environment);
12693                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
12694                         } else {
12695                                 r->environment = NULL;
12696                         }
12697                         ndr->flags = _flags_save_string;
12698                 }
12699                 {
12700                         uint32_t _flags_save_string = ndr->flags;
12701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12702                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
12703                         if (_ptr_dll_name) {
12704                                 NDR_PULL_ALLOC(ndr, r->dll_name);
12705                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
12706                         } else {
12707                                 r->dll_name = NULL;
12708                         }
12709                         ndr->flags = _flags_save_string;
12710                 }
12711         }
12712         if (ndr_flags & NDR_BUFFERS) {
12713                 {
12714                         uint32_t _flags_save_string = ndr->flags;
12715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12716                         if (r->monitor_name) {
12717                                 uint32_t _relative_save_offset;
12718                                 _relative_save_offset = ndr->offset;
12719                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12720                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12721                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12722                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12723                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12724                                 ndr->offset = _relative_save_offset;
12725                         }
12726                         ndr->flags = _flags_save_string;
12727                 }
12728                 {
12729                         uint32_t _flags_save_string = ndr->flags;
12730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12731                         if (r->environment) {
12732                                 uint32_t _relative_save_offset;
12733                                 _relative_save_offset = ndr->offset;
12734                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
12735                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
12736                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
12737                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
12738                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
12739                                 ndr->offset = _relative_save_offset;
12740                         }
12741                         ndr->flags = _flags_save_string;
12742                 }
12743                 {
12744                         uint32_t _flags_save_string = ndr->flags;
12745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12746                         if (r->dll_name) {
12747                                 uint32_t _relative_save_offset;
12748                                 _relative_save_offset = ndr->offset;
12749                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
12750                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12751                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
12752                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
12753                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
12754                                 ndr->offset = _relative_save_offset;
12755                         }
12756                         ndr->flags = _flags_save_string;
12757                 }
12758         }
12759         return NDR_ERR_SUCCESS;
12760 }
12761
12762 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
12763 {
12764         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
12765         ndr->depth++;
12766         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12767         ndr->depth++;
12768         if (r->monitor_name) {
12769                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12770         }
12771         ndr->depth--;
12772         ndr_print_ptr(ndr, "environment", r->environment);
12773         ndr->depth++;
12774         if (r->environment) {
12775                 ndr_print_string(ndr, "environment", r->environment);
12776         }
12777         ndr->depth--;
12778         ndr_print_ptr(ndr, "dll_name", r->dll_name);
12779         ndr->depth++;
12780         if (r->dll_name) {
12781                 ndr_print_string(ndr, "dll_name", r->dll_name);
12782         }
12783         ndr->depth--;
12784         ndr->depth--;
12785 }
12786
12787 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
12788 {
12789         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12790         if (ndr_flags & NDR_SCALARS) {
12791                 int level = ndr_push_get_switch_value(ndr, r);
12792                 switch (level) {
12793                         case 1: {
12794                                 NDR_CHECK(ndr_push_align(ndr, 4));
12795                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12796                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
12797                         break; }
12798
12799                         case 2: {
12800                                 NDR_CHECK(ndr_push_align(ndr, 4));
12801                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12802                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
12803                         break; }
12804
12805                         default: {
12806                         break; }
12807
12808                 }
12809         }
12810         if (ndr_flags & NDR_BUFFERS) {
12811                 int level = ndr_push_get_switch_value(ndr, r);
12812                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12813                 switch (level) {
12814                         case 1:
12815                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
12816                         break;
12817
12818                         case 2:
12819                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
12820                         break;
12821
12822                         default:
12823                         break;
12824
12825                 }
12826         }
12827         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12828         return NDR_ERR_SUCCESS;
12829 }
12830
12831 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
12832 {
12833         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12834         int level;
12835         level = ndr_pull_get_switch_value(ndr, r);
12836         if (ndr_flags & NDR_SCALARS) {
12837                 switch (level) {
12838                         case 1: {
12839                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12840                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12841                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
12842                         break; }
12843
12844                         case 2: {
12845                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12846                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12847                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
12848                         break; }
12849
12850                         default: {
12851                         break; }
12852
12853                 }
12854         }
12855         if (ndr_flags & NDR_BUFFERS) {
12856                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12857                 switch (level) {
12858                         case 1:
12859                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
12860                         break;
12861
12862                         case 2:
12863                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
12864                         break;
12865
12866                         default:
12867                         break;
12868
12869                 }
12870         }
12871         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12872         return NDR_ERR_SUCCESS;
12873 }
12874
12875 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
12876 {
12877         int level;
12878         level = ndr_print_get_switch_value(ndr, r);
12879         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
12880         switch (level) {
12881                 case 1:
12882                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
12883                 break;
12884
12885                 case 2:
12886                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
12887                 break;
12888
12889                 default:
12890                 break;
12891
12892         }
12893 }
12894
12895 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
12896 {
12897         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12898         return NDR_ERR_SUCCESS;
12899 }
12900
12901 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
12902 {
12903         uint32_t v;
12904         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
12905         *r = v;
12906         return NDR_ERR_SUCCESS;
12907 }
12908
12909 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
12910 {
12911         ndr_print_uint32(ndr, name, r);
12912         ndr->depth++;
12913         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
12914         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
12915         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
12916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
12917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
12918         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
12919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
12920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
12921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
12922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
12923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
12924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
12925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
12926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
12927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
12928         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
12929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
12930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
12931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
12932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
12933         ndr->depth--;
12934 }
12935
12936 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
12937 {
12938         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
12939         return NDR_ERR_SUCCESS;
12940 }
12941
12942 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
12943 {
12944         uint16_t v;
12945         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
12946         *r = v;
12947         return NDR_ERR_SUCCESS;
12948 }
12949
12950 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
12951 {
12952         const char *val = NULL;
12953
12954         switch (r) {
12955                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
12956                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
12957                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
12958                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
12959                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
12960                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
12961                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
12962                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
12963                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
12964                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
12965                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
12966                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
12967                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
12968                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
12969                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
12970                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
12971                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
12972                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
12973                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
12974                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
12975                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
12976                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
12977                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
12978                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
12979                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
12980                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
12981         }
12982         ndr_print_enum(ndr, name, "ENUM", val, r);
12983 }
12984
12985 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
12986 {
12987         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
12988         return NDR_ERR_SUCCESS;
12989 }
12990
12991 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
12992 {
12993         uint16_t v;
12994         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
12995         *r = v;
12996         return NDR_ERR_SUCCESS;
12997 }
12998
12999 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
13000 {
13001         const char *val = NULL;
13002
13003         switch (r) {
13004                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
13005                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
13006         }
13007         ndr_print_enum(ndr, name, "ENUM", val, r);
13008 }
13009
13010 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
13011 {
13012         uint32_t cntr_fields_1;
13013         if (ndr_flags & NDR_SCALARS) {
13014                 NDR_CHECK(ndr_push_align(ndr, 4));
13015                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13016                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
13017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
13018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
13019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
13021         }
13022         if (ndr_flags & NDR_BUFFERS) {
13023                 if (r->fields) {
13024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13025                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13026                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
13027                         }
13028                 }
13029         }
13030         return NDR_ERR_SUCCESS;
13031 }
13032
13033 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
13034 {
13035         uint32_t _ptr_fields;
13036         uint32_t cntr_fields_1;
13037         TALLOC_CTX *_mem_save_fields_0;
13038         TALLOC_CTX *_mem_save_fields_1;
13039         if (ndr_flags & NDR_SCALARS) {
13040                 NDR_CHECK(ndr_pull_align(ndr, 4));
13041                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13042                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
13043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
13044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
13045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
13047                 if (_ptr_fields) {
13048                         NDR_PULL_ALLOC(ndr, r->fields);
13049                 } else {
13050                         r->fields = NULL;
13051                 }
13052         }
13053         if (ndr_flags & NDR_BUFFERS) {
13054                 if (r->fields) {
13055                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
13056                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13057                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
13058                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
13059                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
13060                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
13061                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
13062                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
13063                         }
13064                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
13065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
13066                 }
13067                 if (r->fields) {
13068                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
13069                 }
13070         }
13071         return NDR_ERR_SUCCESS;
13072 }
13073
13074 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
13075 {
13076         uint32_t cntr_fields_1;
13077         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
13078         ndr->depth++;
13079         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13080         ndr_print_uint16(ndr, "u1", r->u1);
13081         ndr_print_uint32(ndr, "u2", r->u2);
13082         ndr_print_uint32(ndr, "u3", r->u3);
13083         ndr_print_uint32(ndr, "count", r->count);
13084         ndr_print_ptr(ndr, "fields", r->fields);
13085         ndr->depth++;
13086         if (r->fields) {
13087                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
13088                 ndr->depth++;
13089                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
13090                         char *idx_1=NULL;
13091                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
13092                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
13093                                 free(idx_1);
13094                         }
13095                 }
13096                 ndr->depth--;
13097         }
13098         ndr->depth--;
13099         ndr->depth--;
13100 }
13101
13102 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
13103 {
13104         uint32_t cntr_types_1;
13105         if (ndr_flags & NDR_SCALARS) {
13106                 NDR_CHECK(ndr_push_align(ndr, 4));
13107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13110                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
13111         }
13112         if (ndr_flags & NDR_BUFFERS) {
13113                 if (r->types) {
13114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13115                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13116                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13117                         }
13118                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13119                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13120                         }
13121                 }
13122         }
13123         return NDR_ERR_SUCCESS;
13124 }
13125
13126 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
13127 {
13128         uint32_t _ptr_types;
13129         uint32_t cntr_types_1;
13130         TALLOC_CTX *_mem_save_types_0;
13131         TALLOC_CTX *_mem_save_types_1;
13132         if (ndr_flags & NDR_SCALARS) {
13133                 NDR_CHECK(ndr_pull_align(ndr, 4));
13134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
13138                 if (_ptr_types) {
13139                         NDR_PULL_ALLOC(ndr, r->types);
13140                 } else {
13141                         r->types = NULL;
13142                 }
13143         }
13144         if (ndr_flags & NDR_BUFFERS) {
13145                 if (r->types) {
13146                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
13147                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13148                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
13149                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
13150                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
13151                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
13152                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13153                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
13154                         }
13155                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
13156                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
13157                         }
13158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
13159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
13160                 }
13161                 if (r->types) {
13162                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
13163                 }
13164         }
13165         return NDR_ERR_SUCCESS;
13166 }
13167
13168 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
13169 {
13170         uint32_t cntr_types_1;
13171         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
13172         ndr->depth++;
13173         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13174         ndr_print_uint32(ndr, "flags", r->flags);
13175         ndr_print_uint32(ndr, "count", r->count);
13176         ndr_print_ptr(ndr, "types", r->types);
13177         ndr->depth++;
13178         if (r->types) {
13179                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
13180                 ndr->depth++;
13181                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
13182                         char *idx_1=NULL;
13183                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
13184                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
13185                                 free(idx_1);
13186                         }
13187                 }
13188                 ndr->depth--;
13189         }
13190         ndr->depth--;
13191         ndr->depth--;
13192 }
13193
13194 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
13195 {
13196         if (ndr_flags & NDR_SCALARS) {
13197                 NDR_CHECK(ndr_push_align(ndr, 4));
13198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13199                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
13200         }
13201         if (ndr_flags & NDR_BUFFERS) {
13202                 if (r->string) {
13203                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
13204                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
13205                 }
13206         }
13207         return NDR_ERR_SUCCESS;
13208 }
13209
13210 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
13211 {
13212         uint32_t _ptr_string;
13213         TALLOC_CTX *_mem_save_string_0;
13214         if (ndr_flags & NDR_SCALARS) {
13215                 NDR_CHECK(ndr_pull_align(ndr, 4));
13216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
13218                 if (_ptr_string) {
13219                         NDR_PULL_ALLOC(ndr, r->string);
13220                 } else {
13221                         r->string = NULL;
13222                 }
13223         }
13224         if (ndr_flags & NDR_BUFFERS) {
13225                 if (r->string) {
13226                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
13227                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
13228                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
13229                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
13230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
13231                 }
13232                 if (r->string) {
13233                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
13234                 }
13235         }
13236         return NDR_ERR_SUCCESS;
13237 }
13238
13239 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
13240 {
13241         ndr_print_struct(ndr, name, "spoolss_NotifyString");
13242         ndr->depth++;
13243         ndr_print_uint32(ndr, "size", r->size);
13244         ndr_print_ptr(ndr, "string", r->string);
13245         ndr->depth++;
13246         if (r->string) {
13247                 ndr_print_string(ndr, "string", r->string);
13248         }
13249         ndr->depth--;
13250         ndr->depth--;
13251 }
13252
13253 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
13254 {
13255         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13256         return NDR_ERR_SUCCESS;
13257 }
13258
13259 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
13260 {
13261         uint32_t v;
13262         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13263         *r = v;
13264         return NDR_ERR_SUCCESS;
13265 }
13266
13267 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
13268 {
13269         const char *val = NULL;
13270
13271         switch (r) {
13272                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
13273                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
13274                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
13275                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
13276                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
13277         }
13278         ndr_print_enum(ndr, name, "ENUM", val, r);
13279 }
13280
13281 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
13282 {
13283         if (ndr_flags & NDR_SCALARS) {
13284                 int level = ndr_push_get_switch_value(ndr, r);
13285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13286                 switch (level) {
13287                         case 1: {
13288                                 uint32_t cntr_integer_0;
13289                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13290                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
13291                                 }
13292                         break; }
13293
13294                         case 2: {
13295                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13296                         break; }
13297
13298                         case 3: {
13299                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
13300                         break; }
13301
13302                         case 4: {
13303                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13304                         break; }
13305
13306                         case 5: {
13307                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13308                         break; }
13309
13310                         default:
13311                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13312                 }
13313         }
13314         if (ndr_flags & NDR_BUFFERS) {
13315                 int level = ndr_push_get_switch_value(ndr, r);
13316                 switch (level) {
13317                         case 1:
13318                         break;
13319
13320                         case 2:
13321                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13322                         break;
13323
13324                         case 3:
13325                                 if (r->devmode) {
13326                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
13327                                 }
13328                         break;
13329
13330                         case 4:
13331                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13332                         break;
13333
13334                         case 5:
13335                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13336                         break;
13337
13338                         default:
13339                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13340                 }
13341         }
13342         return NDR_ERR_SUCCESS;
13343 }
13344
13345 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
13346 {
13347         int level;
13348         uint32_t _level;
13349         TALLOC_CTX *_mem_save_devmode_0;
13350         level = ndr_pull_get_switch_value(ndr, r);
13351         if (ndr_flags & NDR_SCALARS) {
13352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13353                 if (_level != level) {
13354                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13355                 }
13356                 switch (level) {
13357                         case 1: {
13358                                 uint32_t cntr_integer_0;
13359                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
13360                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
13361                                 }
13362                         break; }
13363
13364                         case 2: {
13365                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
13366                         break; }
13367
13368                         case 3: {
13369                                 uint32_t _ptr_devmode;
13370                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
13371                                 if (_ptr_devmode) {
13372                                         NDR_PULL_ALLOC(ndr, r->devmode);
13373                                 } else {
13374                                         r->devmode = NULL;
13375                                 }
13376                         break; }
13377
13378                         case 4: {
13379                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
13380                         break; }
13381
13382                         case 5: {
13383                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
13384                         break; }
13385
13386                         default:
13387                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13388                 }
13389         }
13390         if (ndr_flags & NDR_BUFFERS) {
13391                 switch (level) {
13392                         case 1:
13393                         break;
13394
13395                         case 2:
13396                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
13397                         break;
13398
13399                         case 3:
13400                                 if (r->devmode) {
13401                                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
13402                                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
13403                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
13404                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
13405                                 }
13406                         break;
13407
13408                         case 4:
13409                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
13410                         break;
13411
13412                         case 5:
13413                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
13414                         break;
13415
13416                         default:
13417                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13418                 }
13419         }
13420         return NDR_ERR_SUCCESS;
13421 }
13422
13423 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
13424 {
13425         int level;
13426         uint32_t cntr_integer_0;
13427         level = ndr_print_get_switch_value(ndr, r);
13428         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
13429         switch (level) {
13430                 case 1:
13431                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
13432                         ndr->depth++;
13433                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
13434                                 char *idx_0=NULL;
13435                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
13436                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
13437                                         free(idx_0);
13438                                 }
13439                         }
13440                         ndr->depth--;
13441                 break;
13442
13443                 case 2:
13444                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
13445                 break;
13446
13447                 case 3:
13448                         ndr_print_ptr(ndr, "devmode", r->devmode);
13449                         ndr->depth++;
13450                         if (r->devmode) {
13451                                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
13452                         }
13453                         ndr->depth--;
13454                 break;
13455
13456                 case 4:
13457                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
13458                 break;
13459
13460                 case 5:
13461                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
13462                 break;
13463
13464                 default:
13465                         ndr_print_bad_level(ndr, name, level);
13466         }
13467 }
13468
13469 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
13470 {
13471         if (ndr_flags & NDR_SCALARS) {
13472                 NDR_CHECK(ndr_push_align(ndr, 4));
13473                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
13474                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
13475                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
13476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
13477                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
13478                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13479         }
13480         if (ndr_flags & NDR_BUFFERS) {
13481                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13482         }
13483         return NDR_ERR_SUCCESS;
13484 }
13485
13486 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
13487 {
13488         if (ndr_flags & NDR_SCALARS) {
13489                 NDR_CHECK(ndr_pull_align(ndr, 4));
13490                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
13491                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
13492                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
13493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
13494                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
13495                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
13496         }
13497         if (ndr_flags & NDR_BUFFERS) {
13498                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
13499         }
13500         return NDR_ERR_SUCCESS;
13501 }
13502
13503 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
13504 {
13505         ndr_print_struct(ndr, name, "spoolss_Notify");
13506         ndr->depth++;
13507         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
13508         ndr_print_spoolss_Field(ndr, "field", r->field);
13509         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
13510         ndr_print_uint32(ndr, "job_id", r->job_id);
13511         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
13512         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
13513         ndr->depth--;
13514 }
13515
13516 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
13517 {
13518         uint32_t cntr_notifies_0;
13519         if (ndr_flags & NDR_SCALARS) {
13520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13521                 NDR_CHECK(ndr_push_align(ndr, 4));
13522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13525                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13526                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13527                 }
13528         }
13529         if (ndr_flags & NDR_BUFFERS) {
13530                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13531                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13532                 }
13533         }
13534         return NDR_ERR_SUCCESS;
13535 }
13536
13537 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
13538 {
13539         uint32_t cntr_notifies_0;
13540         TALLOC_CTX *_mem_save_notifies_0;
13541         if (ndr_flags & NDR_SCALARS) {
13542                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
13543                 NDR_CHECK(ndr_pull_align(ndr, 4));
13544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
13545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13547                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
13548                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13549                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13550                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13551                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
13552                 }
13553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13554                 if (r->notifies) {
13555                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
13556                 }
13557         }
13558         if (ndr_flags & NDR_BUFFERS) {
13559                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13560                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
13561                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
13562                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
13563                 }
13564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
13565         }
13566         return NDR_ERR_SUCCESS;
13567 }
13568
13569 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
13570 {
13571         uint32_t cntr_notifies_0;
13572         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
13573         ndr->depth++;
13574         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
13575         ndr_print_uint32(ndr, "flags", r->flags);
13576         ndr_print_uint32(ndr, "count", r->count);
13577         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
13578         ndr->depth++;
13579         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
13580                 char *idx_0=NULL;
13581                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
13582                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
13583                         free(idx_0);
13584                 }
13585         }
13586         ndr->depth--;
13587         ndr->depth--;
13588 }
13589
13590 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
13591 {
13592         if (ndr_flags & NDR_SCALARS) {
13593                 int level = ndr_push_get_switch_value(ndr, r);
13594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13595                 switch (level) {
13596                         case 0: {
13597                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
13598                         break; }
13599
13600                         default:
13601                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13602                 }
13603         }
13604         if (ndr_flags & NDR_BUFFERS) {
13605                 int level = ndr_push_get_switch_value(ndr, r);
13606                 switch (level) {
13607                         case 0:
13608                                 if (r->info0) {
13609                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13610                                 }
13611                         break;
13612
13613                         default:
13614                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13615                 }
13616         }
13617         return NDR_ERR_SUCCESS;
13618 }
13619
13620 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
13621 {
13622         int level;
13623         uint32_t _level;
13624         TALLOC_CTX *_mem_save_info0_0;
13625         level = ndr_pull_get_switch_value(ndr, r);
13626         if (ndr_flags & NDR_SCALARS) {
13627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13628                 if (_level != level) {
13629                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
13630                 }
13631                 switch (level) {
13632                         case 0: {
13633                                 uint32_t _ptr_info0;
13634                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
13635                                 if (_ptr_info0) {
13636                                         NDR_PULL_ALLOC(ndr, r->info0);
13637                                 } else {
13638                                         r->info0 = NULL;
13639                                 }
13640                         break; }
13641
13642                         default:
13643                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13644                 }
13645         }
13646         if (ndr_flags & NDR_BUFFERS) {
13647                 switch (level) {
13648                         case 0:
13649                                 if (r->info0) {
13650                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
13651                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
13652                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
13653                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
13654                                 }
13655                         break;
13656
13657                         default:
13658                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13659                 }
13660         }
13661         return NDR_ERR_SUCCESS;
13662 }
13663
13664 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
13665 {
13666         int level;
13667         level = ndr_print_get_switch_value(ndr, r);
13668         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
13669         switch (level) {
13670                 case 0:
13671                         ndr_print_ptr(ndr, "info0", r->info0);
13672                         ndr->depth++;
13673                         if (r->info0) {
13674                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
13675                         }
13676                         ndr->depth--;
13677                 break;
13678
13679                 default:
13680                         ndr_print_bad_level(ndr, name, level);
13681         }
13682 }
13683
13684 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13685 {
13686         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13687         return NDR_ERR_SUCCESS;
13688 }
13689
13690 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13691 {
13692         uint32_t v;
13693         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13694         *r = v;
13695         return NDR_ERR_SUCCESS;
13696 }
13697
13698 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
13699 {
13700         ndr_print_uint32(ndr, name, r);
13701         ndr->depth++;
13702         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
13703         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
13704         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
13705         ndr->depth--;
13706 }
13707
13708 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
13709 {
13710         if (ndr_flags & NDR_SCALARS) {
13711                 NDR_CHECK(ndr_push_align(ndr, 4));
13712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
13714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
13715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13716                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
13717                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
13718                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
13719         }
13720         if (ndr_flags & NDR_BUFFERS) {
13721                 if (r->client) {
13722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13725                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13726                 }
13727                 if (r->user) {
13728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13732                 }
13733         }
13734         return NDR_ERR_SUCCESS;
13735 }
13736
13737 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
13738 {
13739         uint32_t _ptr_client;
13740         TALLOC_CTX *_mem_save_client_0;
13741         uint32_t _ptr_user;
13742         TALLOC_CTX *_mem_save_user_0;
13743         if (ndr_flags & NDR_SCALARS) {
13744                 NDR_CHECK(ndr_pull_align(ndr, 4));
13745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
13747                 if (_ptr_client) {
13748                         NDR_PULL_ALLOC(ndr, r->client);
13749                 } else {
13750                         r->client = NULL;
13751                 }
13752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
13753                 if (_ptr_user) {
13754                         NDR_PULL_ALLOC(ndr, r->user);
13755                 } else {
13756                         r->user = NULL;
13757                 }
13758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
13759                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
13760                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
13761                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
13762         }
13763         if (ndr_flags & NDR_BUFFERS) {
13764                 if (r->client) {
13765                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
13766                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
13767                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
13768                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
13769                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
13770                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
13771                         }
13772                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
13773                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
13774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
13775                 }
13776                 if (r->user) {
13777                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
13778                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
13779                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
13780                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
13781                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
13782                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
13783                         }
13784                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
13785                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
13786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
13787                 }
13788         }
13789         return NDR_ERR_SUCCESS;
13790 }
13791
13792 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
13793 {
13794         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
13795         ndr->depth++;
13796         ndr_print_uint32(ndr, "size", r->size);
13797         ndr_print_ptr(ndr, "client", r->client);
13798         ndr->depth++;
13799         if (r->client) {
13800                 ndr_print_string(ndr, "client", r->client);
13801         }
13802         ndr->depth--;
13803         ndr_print_ptr(ndr, "user", r->user);
13804         ndr->depth++;
13805         if (r->user) {
13806                 ndr_print_string(ndr, "user", r->user);
13807         }
13808         ndr->depth--;
13809         ndr_print_uint32(ndr, "build", r->build);
13810         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
13811         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
13812         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
13813         ndr->depth--;
13814 }
13815
13816 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
13817 {
13818         if (ndr_flags & NDR_SCALARS) {
13819                 NDR_CHECK(ndr_push_align(ndr, 4));
13820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
13821         }
13822         if (ndr_flags & NDR_BUFFERS) {
13823         }
13824         return NDR_ERR_SUCCESS;
13825 }
13826
13827 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
13828 {
13829         if (ndr_flags & NDR_SCALARS) {
13830                 NDR_CHECK(ndr_pull_align(ndr, 4));
13831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
13832         }
13833         if (ndr_flags & NDR_BUFFERS) {
13834         }
13835         return NDR_ERR_SUCCESS;
13836 }
13837
13838 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
13839 {
13840         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
13841         ndr->depth++;
13842         ndr_print_uint32(ndr, "not_used", r->not_used);
13843         ndr->depth--;
13844 }
13845
13846 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
13847 {
13848         if (ndr_flags & NDR_SCALARS) {
13849                 NDR_CHECK(ndr_push_align(ndr, 4));
13850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
13853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
13854                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
13855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13856                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
13857                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
13858                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
13859                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
13860         }
13861         if (ndr_flags & NDR_BUFFERS) {
13862                 if (r->client) {
13863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
13866                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13867                 }
13868                 if (r->user) {
13869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
13872                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13873                 }
13874         }
13875         return NDR_ERR_SUCCESS;
13876 }
13877
13878 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
13879 {
13880         uint32_t _ptr_client;
13881         TALLOC_CTX *_mem_save_client_0;
13882         uint32_t _ptr_user;
13883         TALLOC_CTX *_mem_save_user_0;
13884         if (ndr_flags & NDR_SCALARS) {
13885                 NDR_CHECK(ndr_pull_align(ndr, 4));
13886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
13889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
13890                 if (_ptr_client) {
13891                         NDR_PULL_ALLOC(ndr, r->client);
13892                 } else {
13893                         r->client = NULL;
13894                 }
13895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
13896                 if (_ptr_user) {
13897                         NDR_PULL_ALLOC(ndr, r->user);
13898                 } else {
13899                         r->user = NULL;
13900                 }
13901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
13902                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
13903                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
13904                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
13905                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
13906         }
13907         if (ndr_flags & NDR_BUFFERS) {
13908                 if (r->client) {
13909                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
13910                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
13911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
13912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
13913                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
13914                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
13915                         }
13916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
13917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
13918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
13919                 }
13920                 if (r->user) {
13921                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
13922                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
13923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
13924                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
13925                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
13926                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
13927                         }
13928                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
13929                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
13930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
13931                 }
13932         }
13933         return NDR_ERR_SUCCESS;
13934 }
13935
13936 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
13937 {
13938         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
13939         ndr->depth++;
13940         ndr_print_uint32(ndr, "size", r->size);
13941         ndr_print_uint32(ndr, "flags", r->flags);
13942         ndr_print_uint32(ndr, "size2", r->size2);
13943         ndr_print_ptr(ndr, "client", r->client);
13944         ndr->depth++;
13945         if (r->client) {
13946                 ndr_print_string(ndr, "client", r->client);
13947         }
13948         ndr->depth--;
13949         ndr_print_ptr(ndr, "user", r->user);
13950         ndr->depth++;
13951         if (r->user) {
13952                 ndr_print_string(ndr, "user", r->user);
13953         }
13954         ndr->depth--;
13955         ndr_print_uint32(ndr, "build", r->build);
13956         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
13957         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
13958         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
13959         ndr_print_udlong(ndr, "reserved", r->reserved);
13960         ndr->depth--;
13961 }
13962
13963 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
13964 {
13965         if (ndr_flags & NDR_SCALARS) {
13966                 int level = ndr_push_get_switch_value(ndr, r);
13967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13968                 switch (level) {
13969                         case 1: {
13970                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
13971                         break; }
13972
13973                         case 2: {
13974                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
13975                         break; }
13976
13977                         case 3: {
13978                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
13979                         break; }
13980
13981                         default:
13982                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
13983                 }
13984         }
13985         if (ndr_flags & NDR_BUFFERS) {
13986                 int level = ndr_push_get_switch_value(ndr, r);
13987                 switch (level) {
13988                         case 1:
13989                                 if (r->level1) {
13990                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
13991                                 }
13992                         break;
13993
13994                         case 2:
13995                                 if (r->level2) {
13996                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
13997                                 }
13998                         break;
13999
14000                         case 3:
14001                                 if (r->level3) {
14002                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14003                                 }
14004                         break;
14005
14006                         default:
14007                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14008                 }
14009         }
14010         return NDR_ERR_SUCCESS;
14011 }
14012
14013 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
14014 {
14015         int level;
14016         uint32_t _level;
14017         TALLOC_CTX *_mem_save_level1_0;
14018         TALLOC_CTX *_mem_save_level2_0;
14019         TALLOC_CTX *_mem_save_level3_0;
14020         level = ndr_pull_get_switch_value(ndr, r);
14021         if (ndr_flags & NDR_SCALARS) {
14022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14023                 if (_level != level) {
14024                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14025                 }
14026                 switch (level) {
14027                         case 1: {
14028                                 uint32_t _ptr_level1;
14029                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
14030                                 if (_ptr_level1) {
14031                                         NDR_PULL_ALLOC(ndr, r->level1);
14032                                 } else {
14033                                         r->level1 = NULL;
14034                                 }
14035                         break; }
14036
14037                         case 2: {
14038                                 uint32_t _ptr_level2;
14039                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
14040                                 if (_ptr_level2) {
14041                                         NDR_PULL_ALLOC(ndr, r->level2);
14042                                 } else {
14043                                         r->level2 = NULL;
14044                                 }
14045                         break; }
14046
14047                         case 3: {
14048                                 uint32_t _ptr_level3;
14049                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
14050                                 if (_ptr_level3) {
14051                                         NDR_PULL_ALLOC(ndr, r->level3);
14052                                 } else {
14053                                         r->level3 = NULL;
14054                                 }
14055                         break; }
14056
14057                         default:
14058                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14059                 }
14060         }
14061         if (ndr_flags & NDR_BUFFERS) {
14062                 switch (level) {
14063                         case 1:
14064                                 if (r->level1) {
14065                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14066                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
14067                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
14068                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
14069                                 }
14070                         break;
14071
14072                         case 2:
14073                                 if (r->level2) {
14074                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
14075                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
14076                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
14077                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
14078                                 }
14079                         break;
14080
14081                         case 3:
14082                                 if (r->level3) {
14083                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
14084                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
14085                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
14086                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
14087                                 }
14088                         break;
14089
14090                         default:
14091                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14092                 }
14093         }
14094         return NDR_ERR_SUCCESS;
14095 }
14096
14097 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
14098 {
14099         int level;
14100         level = ndr_print_get_switch_value(ndr, r);
14101         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
14102         switch (level) {
14103                 case 1:
14104                         ndr_print_ptr(ndr, "level1", r->level1);
14105                         ndr->depth++;
14106                         if (r->level1) {
14107                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
14108                         }
14109                         ndr->depth--;
14110                 break;
14111
14112                 case 2:
14113                         ndr_print_ptr(ndr, "level2", r->level2);
14114                         ndr->depth++;
14115                         if (r->level2) {
14116                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
14117                         }
14118                         ndr->depth--;
14119                 break;
14120
14121                 case 3:
14122                         ndr_print_ptr(ndr, "level3", r->level3);
14123                         ndr->depth++;
14124                         if (r->level3) {
14125                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
14126                         }
14127                         ndr->depth--;
14128                 break;
14129
14130                 default:
14131                         ndr_print_bad_level(ndr, name, level);
14132         }
14133 }
14134
14135 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
14136 {
14137         if (ndr_flags & NDR_SCALARS) {
14138                 NDR_CHECK(ndr_push_align(ndr, 4));
14139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
14140                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
14141                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14142         }
14143         if (ndr_flags & NDR_BUFFERS) {
14144                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14145         }
14146         return NDR_ERR_SUCCESS;
14147 }
14148
14149 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
14150 {
14151         if (ndr_flags & NDR_SCALARS) {
14152                 NDR_CHECK(ndr_pull_align(ndr, 4));
14153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
14154                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
14155                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
14156         }
14157         if (ndr_flags & NDR_BUFFERS) {
14158                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
14159         }
14160         return NDR_ERR_SUCCESS;
14161 }
14162
14163 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
14164 {
14165         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
14166         ndr->depth++;
14167         ndr_print_uint32(ndr, "level", r->level);
14168         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
14169         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
14170         ndr->depth--;
14171 }
14172
14173 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14174 {
14175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14176         return NDR_ERR_SUCCESS;
14177 }
14178
14179 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14180 {
14181         uint32_t v;
14182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14183         *r = v;
14184         return NDR_ERR_SUCCESS;
14185 }
14186
14187 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
14188 {
14189         ndr_print_uint32(ndr, name, r);
14190         ndr->depth++;
14191         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
14192         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
14193         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
14194         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
14195         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
14196         ndr->depth--;
14197 }
14198
14199 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14200 {
14201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14202         return NDR_ERR_SUCCESS;
14203 }
14204
14205 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14206 {
14207         uint32_t v;
14208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14209         *r = v;
14210         return NDR_ERR_SUCCESS;
14211 }
14212
14213 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14214 {
14215         ndr_print_uint32(ndr, name, r);
14216         ndr->depth++;
14217         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
14218         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
14219         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
14220         ndr->depth--;
14221 }
14222
14223 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
14224 {
14225         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14226         return NDR_ERR_SUCCESS;
14227 }
14228
14229 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
14230 {
14231         uint32_t v;
14232         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14233         *r = v;
14234         return NDR_ERR_SUCCESS;
14235 }
14236
14237 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
14238 {
14239         const char *val = NULL;
14240
14241         switch (r) {
14242                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
14243                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
14244         }
14245         ndr_print_enum(ndr, name, "ENUM", val, r);
14246 }
14247
14248 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
14249 {
14250         if (ndr_flags & NDR_SCALARS) {
14251                 NDR_CHECK(ndr_push_align(ndr, 4));
14252                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
14254                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14257                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14258                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14260                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14261                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14262                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14263                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14267         }
14268         if (ndr_flags & NDR_BUFFERS) {
14269         }
14270         return NDR_ERR_SUCCESS;
14271 }
14272
14273 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
14274 {
14275         if (ndr_flags & NDR_SCALARS) {
14276                 NDR_CHECK(ndr_pull_align(ndr, 4));
14277                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14279                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14282                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
14283                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14285                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14286                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
14287                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
14288                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14292         }
14293         if (ndr_flags & NDR_BUFFERS) {
14294         }
14295         return NDR_ERR_SUCCESS;
14296 }
14297
14298 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
14299 {
14300         ndr_print_struct(ndr, name, "spoolss_PortData1");
14301         ndr->depth++;
14302         ndr_print_string(ndr, "portname", r->portname);
14303         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
14304         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14305         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14306         ndr_print_uint32(ndr, "reserved", r->reserved);
14307         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14308         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14309         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14310         ndr_print_string(ndr, "queue", r->queue);
14311         ndr_print_string(ndr, "ip_address", r->ip_address);
14312         ndr_print_string(ndr, "hardware_address", r->hardware_address);
14313         ndr_print_string(ndr, "device_type", r->device_type);
14314         ndr_print_uint32(ndr, "port_number", r->port_number);
14315         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14316         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14317         ndr->depth--;
14318 }
14319
14320 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
14321 {
14322         if (ndr_flags & NDR_SCALARS) {
14323                 NDR_CHECK(ndr_push_align(ndr, 4));
14324                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
14325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
14326                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
14327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
14328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14329                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14330                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
14332                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
14333                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
14335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
14336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
14337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
14338         }
14339         if (ndr_flags & NDR_BUFFERS) {
14340         }
14341         return NDR_ERR_SUCCESS;
14342 }
14343
14344 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
14345 {
14346         if (ndr_flags & NDR_SCALARS) {
14347                 NDR_CHECK(ndr_pull_align(ndr, 4));
14348                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
14349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
14350                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
14351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
14352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14353                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
14354                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
14355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
14356                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
14357                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
14358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
14359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
14360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
14361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
14362         }
14363         if (ndr_flags & NDR_BUFFERS) {
14364         }
14365         return NDR_ERR_SUCCESS;
14366 }
14367
14368 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
14369 {
14370         ndr_print_struct(ndr, name, "spoolss_PortData2");
14371         ndr->depth++;
14372         ndr_print_string(ndr, "portname", r->portname);
14373         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
14374         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
14375         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
14376         ndr_print_uint32(ndr, "reserved", r->reserved);
14377         ndr_print_string(ndr, "hostaddress", r->hostaddress);
14378         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
14379         ndr_print_uint32(ndr, "dblspool", r->dblspool);
14380         ndr_print_string(ndr, "queue", r->queue);
14381         ndr_print_string(ndr, "device_type", r->device_type);
14382         ndr_print_uint32(ndr, "port_number", r->port_number);
14383         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
14384         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
14385         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
14386         ndr->depth--;
14387 }
14388
14389 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
14390 {
14391         if (ndr_flags & NDR_SCALARS) {
14392                 NDR_CHECK(ndr_push_align(ndr, 4));
14393                 {
14394                         uint32_t _flags_save_string = ndr->flags;
14395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14396                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
14397                         ndr->flags = _flags_save_string;
14398                 }
14399         }
14400         if (ndr_flags & NDR_BUFFERS) {
14401         }
14402         return NDR_ERR_SUCCESS;
14403 }
14404
14405 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
14406 {
14407         if (ndr_flags & NDR_SCALARS) {
14408                 NDR_CHECK(ndr_pull_align(ndr, 4));
14409                 {
14410                         uint32_t _flags_save_string = ndr->flags;
14411                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14412                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
14413                         ndr->flags = _flags_save_string;
14414                 }
14415         }
14416         if (ndr_flags & NDR_BUFFERS) {
14417         }
14418         return NDR_ERR_SUCCESS;
14419 }
14420
14421 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
14422 {
14423         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
14424         ndr->depth++;
14425         ndr_print_string(ndr, "dll_name", r->dll_name);
14426         ndr->depth--;
14427 }
14428
14429 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14430 {
14431         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14432         return NDR_ERR_SUCCESS;
14433 }
14434
14435 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14436 {
14437         uint32_t v;
14438         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14439         *r = v;
14440         return NDR_ERR_SUCCESS;
14441 }
14442
14443 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
14444 {
14445         ndr_print_uint32(ndr, name, r);
14446         ndr->depth++;
14447         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
14448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
14449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
14450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
14451         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
14452         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
14453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
14454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
14455         ndr->depth--;
14456 }
14457
14458 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
14459 {
14460         if (flags & NDR_IN) {
14461                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
14462                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
14463                 if (r->in.server) {
14464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14467                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14468                 }
14469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14471                 if (r->in.buffer) {
14472                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14473                 }
14474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14475         }
14476         if (flags & NDR_OUT) {
14477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14478                 if (r->out.info) {
14479                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
14480                 }
14481                 if (r->out.needed == NULL) {
14482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14483                 }
14484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14485                 if (r->out.count == NULL) {
14486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14487                 }
14488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
14489                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14490         }
14491         return NDR_ERR_SUCCESS;
14492 }
14493
14494 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
14495 {
14496         uint32_t _ptr_server;
14497         uint32_t _ptr_buffer;
14498         uint32_t _ptr_info;
14499         TALLOC_CTX *_mem_save_server_0;
14500         TALLOC_CTX *_mem_save_buffer_0;
14501         TALLOC_CTX *_mem_save_info_0;
14502         TALLOC_CTX *_mem_save_needed_0;
14503         TALLOC_CTX *_mem_save_count_0;
14504         if (flags & NDR_IN) {
14505                 ZERO_STRUCT(r->out);
14506
14507                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
14508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14509                 if (_ptr_server) {
14510                         NDR_PULL_ALLOC(ndr, r->in.server);
14511                 } else {
14512                         r->in.server = NULL;
14513                 }
14514                 if (r->in.server) {
14515                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14516                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14517                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14518                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14519                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14520                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
14521                         }
14522                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14523                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14525                 }
14526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14528                 if (_ptr_buffer) {
14529                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14530                 } else {
14531                         r->in.buffer = NULL;
14532                 }
14533                 if (r->in.buffer) {
14534                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14535                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14536                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14538                 }
14539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14540                 NDR_PULL_ALLOC(ndr, r->out.needed);
14541                 ZERO_STRUCTP(r->out.needed);
14542                 NDR_PULL_ALLOC(ndr, r->out.count);
14543                 ZERO_STRUCTP(r->out.count);
14544         }
14545         if (flags & NDR_OUT) {
14546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14547                 if (_ptr_info) {
14548                         NDR_PULL_ALLOC(ndr, r->out.info);
14549                 } else {
14550                         r->out.info = NULL;
14551                 }
14552                 if (r->out.info) {
14553                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14554                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14555                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
14556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14557                 }
14558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14559                         NDR_PULL_ALLOC(ndr, r->out.needed);
14560                 }
14561                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14562                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14566                         NDR_PULL_ALLOC(ndr, r->out.count);
14567                 }
14568                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
14569                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
14570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
14571                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
14572                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14573         }
14574         return NDR_ERR_SUCCESS;
14575 }
14576
14577 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
14578 {
14579         uint32_t cntr_info_0;
14580         if (flags & NDR_IN) {
14581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
14583         }
14584         if (flags & NDR_OUT) {
14585                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14586                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14587                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14588                 }
14589                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14590                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14591                 }
14592         }
14593         return NDR_ERR_SUCCESS;
14594 }
14595
14596 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
14597 {
14598         uint32_t cntr_info_0;
14599         TALLOC_CTX *_mem_save_info_0;
14600         if (flags & NDR_IN) {
14601                 ZERO_STRUCT(r->out);
14602
14603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
14605         }
14606         if (flags & NDR_OUT) {
14607                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
14608                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14609                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14610                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14611                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
14612                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
14613                 }
14614                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
14615                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
14616                 }
14617                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14618         }
14619         return NDR_ERR_SUCCESS;
14620 }
14621
14622 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
14623 {
14624         uint32_t cntr_info_1;
14625         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
14626         ndr->depth++;
14627         if (flags & NDR_SET_VALUES) {
14628                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14629         }
14630         if (flags & NDR_IN) {
14631                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
14632                 ndr->depth++;
14633                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
14634                 ndr_print_ptr(ndr, "server", r->in.server);
14635                 ndr->depth++;
14636                 if (r->in.server) {
14637                         ndr_print_string(ndr, "server", r->in.server);
14638                 }
14639                 ndr->depth--;
14640                 ndr_print_uint32(ndr, "level", r->in.level);
14641                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14642                 ndr->depth++;
14643                 if (r->in.buffer) {
14644                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
14645                 }
14646                 ndr->depth--;
14647                 ndr_print_uint32(ndr, "offered", r->in.offered);
14648                 ndr->depth--;
14649         }
14650         if (flags & NDR_OUT) {
14651                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
14652                 ndr->depth++;
14653                 ndr_print_ptr(ndr, "count", r->out.count);
14654                 ndr->depth++;
14655                 ndr_print_uint32(ndr, "count", *r->out.count);
14656                 ndr->depth--;
14657                 ndr_print_ptr(ndr, "info", r->out.info);
14658                 ndr->depth++;
14659                 if (r->out.info) {
14660                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
14661                         ndr->depth++;
14662                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
14663                                 char *idx_1=NULL;
14664                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
14665                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
14666                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
14667                                         free(idx_1);
14668                                 }
14669                         }
14670                         ndr->depth--;
14671                 }
14672                 ndr->depth--;
14673                 ndr_print_ptr(ndr, "needed", r->out.needed);
14674                 ndr->depth++;
14675                 ndr_print_uint32(ndr, "needed", *r->out.needed);
14676                 ndr->depth--;
14677                 ndr_print_WERROR(ndr, "result", r->out.result);
14678                 ndr->depth--;
14679         }
14680         ndr->depth--;
14681 }
14682
14683 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
14684 {
14685         if (flags & NDR_IN) {
14686                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
14687                 if (r->in.printername) {
14688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14689                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14690                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14691                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14692                 }
14693                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
14694                 if (r->in.datatype) {
14695                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14696                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14698                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14699                 }
14700                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14701                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
14702         }
14703         if (flags & NDR_OUT) {
14704                 if (r->out.handle == NULL) {
14705                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14706                 }
14707                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14708                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14709         }
14710         return NDR_ERR_SUCCESS;
14711 }
14712
14713 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
14714 {
14715         uint32_t _ptr_printername;
14716         uint32_t _ptr_datatype;
14717         TALLOC_CTX *_mem_save_printername_0;
14718         TALLOC_CTX *_mem_save_datatype_0;
14719         TALLOC_CTX *_mem_save_handle_0;
14720         if (flags & NDR_IN) {
14721                 ZERO_STRUCT(r->out);
14722
14723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
14724                 if (_ptr_printername) {
14725                         NDR_PULL_ALLOC(ndr, r->in.printername);
14726                 } else {
14727                         r->in.printername = NULL;
14728                 }
14729                 if (r->in.printername) {
14730                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
14731                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
14732                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
14733                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
14734                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
14735                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.printername), ndr_get_array_length(ndr, &r->in.printername));
14736                         }
14737                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
14738                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
14739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
14740                 }
14741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14742                 if (_ptr_datatype) {
14743                         NDR_PULL_ALLOC(ndr, r->in.datatype);
14744                 } else {
14745                         r->in.datatype = NULL;
14746                 }
14747                 if (r->in.datatype) {
14748                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14749                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
14750                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
14751                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
14752                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
14753                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
14754                         }
14755                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
14756                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
14757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14758                 }
14759                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14760                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
14761                 NDR_PULL_ALLOC(ndr, r->out.handle);
14762                 ZERO_STRUCTP(r->out.handle);
14763         }
14764         if (flags & NDR_OUT) {
14765                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14766                         NDR_PULL_ALLOC(ndr, r->out.handle);
14767                 }
14768                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14769                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14770                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14772                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14773         }
14774         return NDR_ERR_SUCCESS;
14775 }
14776
14777 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
14778 {
14779         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
14780         ndr->depth++;
14781         if (flags & NDR_SET_VALUES) {
14782                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14783         }
14784         if (flags & NDR_IN) {
14785                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
14786                 ndr->depth++;
14787                 ndr_print_ptr(ndr, "printername", r->in.printername);
14788                 ndr->depth++;
14789                 if (r->in.printername) {
14790                         ndr_print_string(ndr, "printername", r->in.printername);
14791                 }
14792                 ndr->depth--;
14793                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
14794                 ndr->depth++;
14795                 if (r->in.datatype) {
14796                         ndr_print_string(ndr, "datatype", r->in.datatype);
14797                 }
14798                 ndr->depth--;
14799                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
14800                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
14801                 ndr->depth--;
14802         }
14803         if (flags & NDR_OUT) {
14804                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
14805                 ndr->depth++;
14806                 ndr_print_ptr(ndr, "handle", r->out.handle);
14807                 ndr->depth++;
14808                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14809                 ndr->depth--;
14810                 ndr_print_WERROR(ndr, "result", r->out.result);
14811                 ndr->depth--;
14812         }
14813         ndr->depth--;
14814 }
14815
14816 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
14817 {
14818         if (flags & NDR_IN) {
14819                 if (r->in.handle == NULL) {
14820                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14821                 }
14822                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
14824                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
14825                 if (r->in.ctr) {
14826                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14827                 }
14828                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
14829         }
14830         if (flags & NDR_OUT) {
14831                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14832         }
14833         return NDR_ERR_SUCCESS;
14834 }
14835
14836 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
14837 {
14838         uint32_t _ptr_ctr;
14839         TALLOC_CTX *_mem_save_handle_0;
14840         TALLOC_CTX *_mem_save_ctr_0;
14841         if (flags & NDR_IN) {
14842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14843                         NDR_PULL_ALLOC(ndr, r->in.handle);
14844                 }
14845                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14846                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14847                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
14850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
14851                 if (_ptr_ctr) {
14852                         NDR_PULL_ALLOC(ndr, r->in.ctr);
14853                 } else {
14854                         r->in.ctr = NULL;
14855                 }
14856                 if (r->in.ctr) {
14857                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14858                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
14859                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
14860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
14861                 }
14862                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
14863         }
14864         if (flags & NDR_OUT) {
14865                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14866         }
14867         return NDR_ERR_SUCCESS;
14868 }
14869
14870 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
14871 {
14872         ndr_print_struct(ndr, name, "spoolss_SetJob");
14873         ndr->depth++;
14874         if (flags & NDR_SET_VALUES) {
14875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14876         }
14877         if (flags & NDR_IN) {
14878                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
14879                 ndr->depth++;
14880                 ndr_print_ptr(ndr, "handle", r->in.handle);
14881                 ndr->depth++;
14882                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14883                 ndr->depth--;
14884                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
14885                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
14886                 ndr->depth++;
14887                 if (r->in.ctr) {
14888                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
14889                 }
14890                 ndr->depth--;
14891                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
14892                 ndr->depth--;
14893         }
14894         if (flags & NDR_OUT) {
14895                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
14896                 ndr->depth++;
14897                 ndr_print_WERROR(ndr, "result", r->out.result);
14898                 ndr->depth--;
14899         }
14900         ndr->depth--;
14901 }
14902
14903 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
14904 {
14905         if (flags & NDR_IN) {
14906                 if (r->in.handle == NULL) {
14907                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14908                 }
14909                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
14911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14913                 if (r->in.buffer) {
14914                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
14915                 }
14916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
14917         }
14918         if (flags & NDR_OUT) {
14919                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
14920                 if (r->out.info) {
14921                         {
14922                                 struct ndr_push *_ndr_info;
14923                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
14924                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
14925                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14926                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
14927                         }
14928                 }
14929                 if (r->out.needed == NULL) {
14930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14931                 }
14932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
14933                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14934         }
14935         return NDR_ERR_SUCCESS;
14936 }
14937
14938 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
14939 {
14940         uint32_t _ptr_buffer;
14941         uint32_t _ptr_info;
14942         TALLOC_CTX *_mem_save_handle_0;
14943         TALLOC_CTX *_mem_save_buffer_0;
14944         TALLOC_CTX *_mem_save_info_0;
14945         TALLOC_CTX *_mem_save_needed_0;
14946         if (flags & NDR_IN) {
14947                 ZERO_STRUCT(r->out);
14948
14949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14950                         NDR_PULL_ALLOC(ndr, r->in.handle);
14951                 }
14952                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14953                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14954                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
14957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14959                 if (_ptr_buffer) {
14960                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14961                 } else {
14962                         r->in.buffer = NULL;
14963                 }
14964                 if (r->in.buffer) {
14965                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14966                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14967                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
14968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14969                 }
14970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
14971                 NDR_PULL_ALLOC(ndr, r->out.needed);
14972                 ZERO_STRUCTP(r->out.needed);
14973         }
14974         if (flags & NDR_OUT) {
14975                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14976                 if (_ptr_info) {
14977                         NDR_PULL_ALLOC(ndr, r->out.info);
14978                 } else {
14979                         r->out.info = NULL;
14980                 }
14981                 if (r->out.info) {
14982                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14983                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14984                         {
14985                                 struct ndr_pull *_ndr_info;
14986                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
14987                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
14988                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14989                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
14990                         }
14991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14992                 }
14993                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14994                         NDR_PULL_ALLOC(ndr, r->out.needed);
14995                 }
14996                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14997                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14999                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15000                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15001         }
15002         return NDR_ERR_SUCCESS;
15003 }
15004
15005 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
15006 {
15007         ndr_print_struct(ndr, name, "spoolss_GetJob");
15008         ndr->depth++;
15009         if (flags & NDR_SET_VALUES) {
15010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15011         }
15012         if (flags & NDR_IN) {
15013                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
15014                 ndr->depth++;
15015                 ndr_print_ptr(ndr, "handle", r->in.handle);
15016                 ndr->depth++;
15017                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15018                 ndr->depth--;
15019                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
15020                 ndr_print_uint32(ndr, "level", r->in.level);
15021                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15022                 ndr->depth++;
15023                 if (r->in.buffer) {
15024                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15025                 }
15026                 ndr->depth--;
15027                 ndr_print_uint32(ndr, "offered", r->in.offered);
15028                 ndr->depth--;
15029         }
15030         if (flags & NDR_OUT) {
15031                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
15032                 ndr->depth++;
15033                 ndr_print_ptr(ndr, "info", r->out.info);
15034                 ndr->depth++;
15035                 if (r->out.info) {
15036                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15037                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
15038                 }
15039                 ndr->depth--;
15040                 ndr_print_ptr(ndr, "needed", r->out.needed);
15041                 ndr->depth++;
15042                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15043                 ndr->depth--;
15044                 ndr_print_WERROR(ndr, "result", r->out.result);
15045                 ndr->depth--;
15046         }
15047         ndr->depth--;
15048 }
15049
15050 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
15051 {
15052         if (flags & NDR_IN) {
15053                 if (r->in.handle == NULL) {
15054                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15055                 }
15056                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
15058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
15059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15061                 if (r->in.buffer) {
15062                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15063                 }
15064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15065         }
15066         if (flags & NDR_OUT) {
15067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15068                 if (r->out.info) {
15069                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15070                 }
15071                 if (r->out.needed == NULL) {
15072                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15073                 }
15074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15075                 if (r->out.count == NULL) {
15076                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15077                 }
15078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15079                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15080         }
15081         return NDR_ERR_SUCCESS;
15082 }
15083
15084 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
15085 {
15086         uint32_t _ptr_buffer;
15087         uint32_t _ptr_info;
15088         TALLOC_CTX *_mem_save_handle_0;
15089         TALLOC_CTX *_mem_save_buffer_0;
15090         TALLOC_CTX *_mem_save_info_0;
15091         TALLOC_CTX *_mem_save_needed_0;
15092         TALLOC_CTX *_mem_save_count_0;
15093         if (flags & NDR_IN) {
15094                 ZERO_STRUCT(r->out);
15095
15096                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15097                         NDR_PULL_ALLOC(ndr, r->in.handle);
15098                 }
15099                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15100                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15101                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
15104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
15105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15107                 if (_ptr_buffer) {
15108                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15109                 } else {
15110                         r->in.buffer = NULL;
15111                 }
15112                 if (r->in.buffer) {
15113                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15114                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15115                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15117                 }
15118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15119                 NDR_PULL_ALLOC(ndr, r->out.needed);
15120                 ZERO_STRUCTP(r->out.needed);
15121                 NDR_PULL_ALLOC(ndr, r->out.count);
15122                 ZERO_STRUCTP(r->out.count);
15123         }
15124         if (flags & NDR_OUT) {
15125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15126                 if (_ptr_info) {
15127                         NDR_PULL_ALLOC(ndr, r->out.info);
15128                 } else {
15129                         r->out.info = NULL;
15130                 }
15131                 if (r->out.info) {
15132                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15133                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15134                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15136                 }
15137                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15138                         NDR_PULL_ALLOC(ndr, r->out.needed);
15139                 }
15140                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15141                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15144                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15145                         NDR_PULL_ALLOC(ndr, r->out.count);
15146                 }
15147                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15148                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15150                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15151                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15152         }
15153         return NDR_ERR_SUCCESS;
15154 }
15155
15156 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
15157 {
15158         uint32_t cntr_info_0;
15159         if (flags & NDR_IN) {
15160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15162         }
15163         if (flags & NDR_OUT) {
15164                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15165                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15166                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15167                 }
15168                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15169                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15170                 }
15171         }
15172         return NDR_ERR_SUCCESS;
15173 }
15174
15175 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
15176 {
15177         uint32_t cntr_info_0;
15178         TALLOC_CTX *_mem_save_info_0;
15179         if (flags & NDR_IN) {
15180                 ZERO_STRUCT(r->out);
15181
15182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15184         }
15185         if (flags & NDR_OUT) {
15186                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15187                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15188                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15189                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15190                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15191                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15192                 }
15193                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15194                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15195                 }
15196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15197         }
15198         return NDR_ERR_SUCCESS;
15199 }
15200
15201 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
15202 {
15203         uint32_t cntr_info_1;
15204         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
15205         ndr->depth++;
15206         if (flags & NDR_SET_VALUES) {
15207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15208         }
15209         if (flags & NDR_IN) {
15210                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
15211                 ndr->depth++;
15212                 ndr_print_ptr(ndr, "handle", r->in.handle);
15213                 ndr->depth++;
15214                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15215                 ndr->depth--;
15216                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
15217                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
15218                 ndr_print_uint32(ndr, "level", r->in.level);
15219                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15220                 ndr->depth++;
15221                 if (r->in.buffer) {
15222                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15223                 }
15224                 ndr->depth--;
15225                 ndr_print_uint32(ndr, "offered", r->in.offered);
15226                 ndr->depth--;
15227         }
15228         if (flags & NDR_OUT) {
15229                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
15230                 ndr->depth++;
15231                 ndr_print_ptr(ndr, "count", r->out.count);
15232                 ndr->depth++;
15233                 ndr_print_uint32(ndr, "count", *r->out.count);
15234                 ndr->depth--;
15235                 ndr_print_ptr(ndr, "info", r->out.info);
15236                 ndr->depth++;
15237                 if (r->out.info) {
15238                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15239                         ndr->depth++;
15240                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15241                                 char *idx_1=NULL;
15242                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15243                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15244                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
15245                                         free(idx_1);
15246                                 }
15247                         }
15248                         ndr->depth--;
15249                 }
15250                 ndr->depth--;
15251                 ndr_print_ptr(ndr, "needed", r->out.needed);
15252                 ndr->depth++;
15253                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15254                 ndr->depth--;
15255                 ndr_print_WERROR(ndr, "result", r->out.result);
15256                 ndr->depth--;
15257         }
15258         ndr->depth--;
15259 }
15260
15261 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
15262 {
15263         if (flags & NDR_IN) {
15264         }
15265         if (flags & NDR_OUT) {
15266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15267         }
15268         return NDR_ERR_SUCCESS;
15269 }
15270
15271 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
15272 {
15273         if (flags & NDR_IN) {
15274         }
15275         if (flags & NDR_OUT) {
15276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15277         }
15278         return NDR_ERR_SUCCESS;
15279 }
15280
15281 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
15282 {
15283         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
15284         ndr->depth++;
15285         if (flags & NDR_SET_VALUES) {
15286                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15287         }
15288         if (flags & NDR_IN) {
15289                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
15290                 ndr->depth++;
15291                 ndr->depth--;
15292         }
15293         if (flags & NDR_OUT) {
15294                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
15295                 ndr->depth++;
15296                 ndr_print_WERROR(ndr, "result", r->out.result);
15297                 ndr->depth--;
15298         }
15299         ndr->depth--;
15300 }
15301
15302 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
15303 {
15304         if (flags & NDR_IN) {
15305                 if (r->in.handle == NULL) {
15306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15307                 }
15308                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15309         }
15310         if (flags & NDR_OUT) {
15311                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15312         }
15313         return NDR_ERR_SUCCESS;
15314 }
15315
15316 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
15317 {
15318         TALLOC_CTX *_mem_save_handle_0;
15319         if (flags & NDR_IN) {
15320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15321                         NDR_PULL_ALLOC(ndr, r->in.handle);
15322                 }
15323                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15324                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15325                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15327         }
15328         if (flags & NDR_OUT) {
15329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15330         }
15331         return NDR_ERR_SUCCESS;
15332 }
15333
15334 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
15335 {
15336         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
15337         ndr->depth++;
15338         if (flags & NDR_SET_VALUES) {
15339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15340         }
15341         if (flags & NDR_IN) {
15342                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
15343                 ndr->depth++;
15344                 ndr_print_ptr(ndr, "handle", r->in.handle);
15345                 ndr->depth++;
15346                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15347                 ndr->depth--;
15348                 ndr->depth--;
15349         }
15350         if (flags & NDR_OUT) {
15351                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
15352                 ndr->depth++;
15353                 ndr_print_WERROR(ndr, "result", r->out.result);
15354                 ndr->depth--;
15355         }
15356         ndr->depth--;
15357 }
15358
15359 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
15360 {
15361         if (flags & NDR_IN) {
15362                 if (r->in.handle == NULL) {
15363                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15364                 }
15365                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15366                 if (r->in.info_ctr == NULL) {
15367                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15368                 }
15369                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15370                 if (r->in.devmode_ctr == NULL) {
15371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15372                 }
15373                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15374                 if (r->in.secdesc_ctr == NULL) {
15375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15376                 }
15377                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15378                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
15379         }
15380         if (flags & NDR_OUT) {
15381                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15382         }
15383         return NDR_ERR_SUCCESS;
15384 }
15385
15386 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
15387 {
15388         TALLOC_CTX *_mem_save_handle_0;
15389         TALLOC_CTX *_mem_save_info_ctr_0;
15390         TALLOC_CTX *_mem_save_devmode_ctr_0;
15391         TALLOC_CTX *_mem_save_secdesc_ctr_0;
15392         if (flags & NDR_IN) {
15393                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15394                         NDR_PULL_ALLOC(ndr, r->in.handle);
15395                 }
15396                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15397                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15398                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15400                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15401                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15402                 }
15403                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15404                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15405                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15406                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15407                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15408                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
15409                 }
15410                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15411                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
15412                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
15413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15414                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15415                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
15416                 }
15417                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15418                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
15419                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
15420                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15421                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
15422         }
15423         if (flags & NDR_OUT) {
15424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15425         }
15426         return NDR_ERR_SUCCESS;
15427 }
15428
15429 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
15430 {
15431         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
15432         ndr->depth++;
15433         if (flags & NDR_SET_VALUES) {
15434                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15435         }
15436         if (flags & NDR_IN) {
15437                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
15438                 ndr->depth++;
15439                 ndr_print_ptr(ndr, "handle", r->in.handle);
15440                 ndr->depth++;
15441                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15442                 ndr->depth--;
15443                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15444                 ndr->depth++;
15445                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15446                 ndr->depth--;
15447                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
15448                 ndr->depth++;
15449                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
15450                 ndr->depth--;
15451                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15452                 ndr->depth++;
15453                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
15454                 ndr->depth--;
15455                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
15456                 ndr->depth--;
15457         }
15458         if (flags & NDR_OUT) {
15459                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
15460                 ndr->depth++;
15461                 ndr_print_WERROR(ndr, "result", r->out.result);
15462                 ndr->depth--;
15463         }
15464         ndr->depth--;
15465 }
15466
15467 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
15468 {
15469         if (flags & NDR_IN) {
15470                 if (r->in.handle == NULL) {
15471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15472                 }
15473                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15476                 if (r->in.buffer) {
15477                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15478                 }
15479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15480         }
15481         if (flags & NDR_OUT) {
15482                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15483                 if (r->out.info) {
15484                         {
15485                                 struct ndr_push *_ndr_info;
15486                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15487                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
15488                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15489                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15490                         }
15491                 }
15492                 if (r->out.needed == NULL) {
15493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15494                 }
15495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15496                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15497         }
15498         return NDR_ERR_SUCCESS;
15499 }
15500
15501 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
15502 {
15503         uint32_t _ptr_buffer;
15504         uint32_t _ptr_info;
15505         TALLOC_CTX *_mem_save_handle_0;
15506         TALLOC_CTX *_mem_save_buffer_0;
15507         TALLOC_CTX *_mem_save_info_0;
15508         TALLOC_CTX *_mem_save_needed_0;
15509         if (flags & NDR_IN) {
15510                 ZERO_STRUCT(r->out);
15511
15512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15513                         NDR_PULL_ALLOC(ndr, r->in.handle);
15514                 }
15515                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15516                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15517                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15521                 if (_ptr_buffer) {
15522                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15523                 } else {
15524                         r->in.buffer = NULL;
15525                 }
15526                 if (r->in.buffer) {
15527                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15528                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15529                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15531                 }
15532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15533                 NDR_PULL_ALLOC(ndr, r->out.needed);
15534                 ZERO_STRUCTP(r->out.needed);
15535         }
15536         if (flags & NDR_OUT) {
15537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15538                 if (_ptr_info) {
15539                         NDR_PULL_ALLOC(ndr, r->out.info);
15540                 } else {
15541                         r->out.info = NULL;
15542                 }
15543                 if (r->out.info) {
15544                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15545                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15546                         {
15547                                 struct ndr_pull *_ndr_info;
15548                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
15549                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
15550                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15551                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
15552                         }
15553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15554                 }
15555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15556                         NDR_PULL_ALLOC(ndr, r->out.needed);
15557                 }
15558                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15559                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15563         }
15564         return NDR_ERR_SUCCESS;
15565 }
15566
15567 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
15568 {
15569         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
15570         ndr->depth++;
15571         if (flags & NDR_SET_VALUES) {
15572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15573         }
15574         if (flags & NDR_IN) {
15575                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
15576                 ndr->depth++;
15577                 ndr_print_ptr(ndr, "handle", r->in.handle);
15578                 ndr->depth++;
15579                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15580                 ndr->depth--;
15581                 ndr_print_uint32(ndr, "level", r->in.level);
15582                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15583                 ndr->depth++;
15584                 if (r->in.buffer) {
15585                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15586                 }
15587                 ndr->depth--;
15588                 ndr_print_uint32(ndr, "offered", r->in.offered);
15589                 ndr->depth--;
15590         }
15591         if (flags & NDR_OUT) {
15592                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
15593                 ndr->depth++;
15594                 ndr_print_ptr(ndr, "info", r->out.info);
15595                 ndr->depth++;
15596                 if (r->out.info) {
15597                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15598                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
15599                 }
15600                 ndr->depth--;
15601                 ndr_print_ptr(ndr, "needed", r->out.needed);
15602                 ndr->depth++;
15603                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15604                 ndr->depth--;
15605                 ndr_print_WERROR(ndr, "result", r->out.result);
15606                 ndr->depth--;
15607         }
15608         ndr->depth--;
15609 }
15610
15611 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
15612 {
15613         if (flags & NDR_IN) {
15614                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
15615                 if (r->in.servername) {
15616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
15617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
15619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15620                 }
15621                 if (r->in.info_ctr == NULL) {
15622                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15623                 }
15624                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15625         }
15626         if (flags & NDR_OUT) {
15627                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15628         }
15629         return NDR_ERR_SUCCESS;
15630 }
15631
15632 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
15633 {
15634         uint32_t _ptr_servername;
15635         TALLOC_CTX *_mem_save_servername_0;
15636         TALLOC_CTX *_mem_save_info_ctr_0;
15637         if (flags & NDR_IN) {
15638                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
15639                 if (_ptr_servername) {
15640                         NDR_PULL_ALLOC(ndr, r->in.servername);
15641                 } else {
15642                         r->in.servername = NULL;
15643                 }
15644                 if (r->in.servername) {
15645                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
15646                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
15647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
15648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
15649                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
15650                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
15651                         }
15652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
15653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
15654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
15655                 }
15656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15657                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15658                 }
15659                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15661                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15663         }
15664         if (flags & NDR_OUT) {
15665                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15666         }
15667         return NDR_ERR_SUCCESS;
15668 }
15669
15670 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
15671 {
15672         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
15673         ndr->depth++;
15674         if (flags & NDR_SET_VALUES) {
15675                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15676         }
15677         if (flags & NDR_IN) {
15678                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
15679                 ndr->depth++;
15680                 ndr_print_ptr(ndr, "servername", r->in.servername);
15681                 ndr->depth++;
15682                 if (r->in.servername) {
15683                         ndr_print_string(ndr, "servername", r->in.servername);
15684                 }
15685                 ndr->depth--;
15686                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15687                 ndr->depth++;
15688                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15689                 ndr->depth--;
15690                 ndr->depth--;
15691         }
15692         if (flags & NDR_OUT) {
15693                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
15694                 ndr->depth++;
15695                 ndr_print_WERROR(ndr, "result", r->out.result);
15696                 ndr->depth--;
15697         }
15698         ndr->depth--;
15699 }
15700
15701 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
15702 {
15703         if (flags & NDR_IN) {
15704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
15705                 if (r->in.server) {
15706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15710                 }
15711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
15712                 if (r->in.environment) {
15713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
15716                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15717                 }
15718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
15720                 if (r->in.buffer) {
15721                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
15722                 }
15723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15724         }
15725         if (flags & NDR_OUT) {
15726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
15727                 if (r->out.info) {
15728                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
15729                 }
15730                 if (r->out.needed == NULL) {
15731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15732                 }
15733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15734                 if (r->out.count == NULL) {
15735                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15736                 }
15737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15738                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15739         }
15740         return NDR_ERR_SUCCESS;
15741 }
15742
15743 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
15744 {
15745         uint32_t _ptr_server;
15746         uint32_t _ptr_environment;
15747         uint32_t _ptr_buffer;
15748         uint32_t _ptr_info;
15749         TALLOC_CTX *_mem_save_server_0;
15750         TALLOC_CTX *_mem_save_environment_0;
15751         TALLOC_CTX *_mem_save_buffer_0;
15752         TALLOC_CTX *_mem_save_info_0;
15753         TALLOC_CTX *_mem_save_needed_0;
15754         TALLOC_CTX *_mem_save_count_0;
15755         if (flags & NDR_IN) {
15756                 ZERO_STRUCT(r->out);
15757
15758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
15759                 if (_ptr_server) {
15760                         NDR_PULL_ALLOC(ndr, r->in.server);
15761                 } else {
15762                         r->in.server = NULL;
15763                 }
15764                 if (r->in.server) {
15765                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
15766                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
15767                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
15768                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
15769                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
15770                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
15771                         }
15772                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
15773                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
15774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
15775                 }
15776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
15777                 if (_ptr_environment) {
15778                         NDR_PULL_ALLOC(ndr, r->in.environment);
15779                 } else {
15780                         r->in.environment = NULL;
15781                 }
15782                 if (r->in.environment) {
15783                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
15784                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
15785                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
15786                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
15787                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
15788                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
15789                         }
15790                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
15791                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
15792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
15793                 }
15794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
15796                 if (_ptr_buffer) {
15797                         NDR_PULL_ALLOC(ndr, r->in.buffer);
15798                 } else {
15799                         r->in.buffer = NULL;
15800                 }
15801                 if (r->in.buffer) {
15802                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15803                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
15804                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15805                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
15806                 }
15807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15808                 NDR_PULL_ALLOC(ndr, r->out.needed);
15809                 ZERO_STRUCTP(r->out.needed);
15810                 NDR_PULL_ALLOC(ndr, r->out.count);
15811                 ZERO_STRUCTP(r->out.count);
15812         }
15813         if (flags & NDR_OUT) {
15814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15815                 if (_ptr_info) {
15816                         NDR_PULL_ALLOC(ndr, r->out.info);
15817                 } else {
15818                         r->out.info = NULL;
15819                 }
15820                 if (r->out.info) {
15821                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15822                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15823                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
15824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15825                 }
15826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15827                         NDR_PULL_ALLOC(ndr, r->out.needed);
15828                 }
15829                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15830                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15834                         NDR_PULL_ALLOC(ndr, r->out.count);
15835                 }
15836                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15837                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15839                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15840                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15841         }
15842         return NDR_ERR_SUCCESS;
15843 }
15844
15845 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
15846 {
15847         uint32_t cntr_info_0;
15848         if (flags & NDR_IN) {
15849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
15851         }
15852         if (flags & NDR_OUT) {
15853                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15854                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15855                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15856                 }
15857                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15858                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15859                 }
15860         }
15861         return NDR_ERR_SUCCESS;
15862 }
15863
15864 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
15865 {
15866         uint32_t cntr_info_0;
15867         TALLOC_CTX *_mem_save_info_0;
15868         if (flags & NDR_IN) {
15869                 ZERO_STRUCT(r->out);
15870
15871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
15873         }
15874         if (flags & NDR_OUT) {
15875                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
15876                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15877                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
15878                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15879                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
15880                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
15881                 }
15882                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
15883                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
15884                 }
15885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15886         }
15887         return NDR_ERR_SUCCESS;
15888 }
15889
15890 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
15891 {
15892         uint32_t cntr_info_1;
15893         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
15894         ndr->depth++;
15895         if (flags & NDR_SET_VALUES) {
15896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15897         }
15898         if (flags & NDR_IN) {
15899                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
15900                 ndr->depth++;
15901                 ndr_print_ptr(ndr, "server", r->in.server);
15902                 ndr->depth++;
15903                 if (r->in.server) {
15904                         ndr_print_string(ndr, "server", r->in.server);
15905                 }
15906                 ndr->depth--;
15907                 ndr_print_ptr(ndr, "environment", r->in.environment);
15908                 ndr->depth++;
15909                 if (r->in.environment) {
15910                         ndr_print_string(ndr, "environment", r->in.environment);
15911                 }
15912                 ndr->depth--;
15913                 ndr_print_uint32(ndr, "level", r->in.level);
15914                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
15915                 ndr->depth++;
15916                 if (r->in.buffer) {
15917                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
15918                 }
15919                 ndr->depth--;
15920                 ndr_print_uint32(ndr, "offered", r->in.offered);
15921                 ndr->depth--;
15922         }
15923         if (flags & NDR_OUT) {
15924                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
15925                 ndr->depth++;
15926                 ndr_print_ptr(ndr, "count", r->out.count);
15927                 ndr->depth++;
15928                 ndr_print_uint32(ndr, "count", *r->out.count);
15929                 ndr->depth--;
15930                 ndr_print_ptr(ndr, "info", r->out.info);
15931                 ndr->depth++;
15932                 if (r->out.info) {
15933                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
15934                         ndr->depth++;
15935                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
15936                                 char *idx_1=NULL;
15937                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
15938                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
15939                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
15940                                         free(idx_1);
15941                                 }
15942                         }
15943                         ndr->depth--;
15944                 }
15945                 ndr->depth--;
15946                 ndr_print_ptr(ndr, "needed", r->out.needed);
15947                 ndr->depth++;
15948                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15949                 ndr->depth--;
15950                 ndr_print_WERROR(ndr, "result", r->out.result);
15951                 ndr->depth--;
15952         }
15953         ndr->depth--;
15954 }
15955
15956 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
15957 {
15958         if (flags & NDR_IN) {
15959         }
15960         if (flags & NDR_OUT) {
15961                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15962         }
15963         return NDR_ERR_SUCCESS;
15964 }
15965
15966 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
15967 {
15968         if (flags & NDR_IN) {
15969         }
15970         if (flags & NDR_OUT) {
15971                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15972         }
15973         return NDR_ERR_SUCCESS;
15974 }
15975
15976 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
15977 {
15978         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
15979         ndr->depth++;
15980         if (flags & NDR_SET_VALUES) {
15981                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15982         }
15983         if (flags & NDR_IN) {
15984                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
15985                 ndr->depth++;
15986                 ndr->depth--;
15987         }
15988         if (flags & NDR_OUT) {
15989                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
15990                 ndr->depth++;
15991                 ndr_print_WERROR(ndr, "result", r->out.result);
15992                 ndr->depth--;
15993         }
15994         ndr->depth--;
15995 }
15996
15997 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
15998 {
15999         if (flags & NDR_IN) {
16000                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16001                 if (r->in.server) {
16002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16005                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16006                 }
16007                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16008                 if (r->in.environment) {
16009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16012                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16013                 }
16014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16016                 if (r->in.buffer) {
16017                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16018                 }
16019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16020         }
16021         if (flags & NDR_OUT) {
16022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16023                 if (r->out.info) {
16024                         {
16025                                 struct ndr_push *_ndr_info;
16026                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16027                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
16028                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16029                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16030                         }
16031                 }
16032                 if (r->out.needed == NULL) {
16033                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16034                 }
16035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16036                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16037         }
16038         return NDR_ERR_SUCCESS;
16039 }
16040
16041 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
16042 {
16043         uint32_t _ptr_server;
16044         uint32_t _ptr_environment;
16045         uint32_t _ptr_buffer;
16046         uint32_t _ptr_info;
16047         TALLOC_CTX *_mem_save_server_0;
16048         TALLOC_CTX *_mem_save_environment_0;
16049         TALLOC_CTX *_mem_save_buffer_0;
16050         TALLOC_CTX *_mem_save_info_0;
16051         TALLOC_CTX *_mem_save_needed_0;
16052         if (flags & NDR_IN) {
16053                 ZERO_STRUCT(r->out);
16054
16055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16056                 if (_ptr_server) {
16057                         NDR_PULL_ALLOC(ndr, r->in.server);
16058                 } else {
16059                         r->in.server = NULL;
16060                 }
16061                 if (r->in.server) {
16062                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16063                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16064                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16065                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16066                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16067                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
16068                         }
16069                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16070                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16072                 }
16073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16074                 if (_ptr_environment) {
16075                         NDR_PULL_ALLOC(ndr, r->in.environment);
16076                 } else {
16077                         r->in.environment = NULL;
16078                 }
16079                 if (r->in.environment) {
16080                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16081                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16082                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16083                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16084                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16085                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
16086                         }
16087                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16088                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16089                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16090                 }
16091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16092                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16093                 if (_ptr_buffer) {
16094                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16095                 } else {
16096                         r->in.buffer = NULL;
16097                 }
16098                 if (r->in.buffer) {
16099                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16100                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16101                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16103                 }
16104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16105                 NDR_PULL_ALLOC(ndr, r->out.needed);
16106                 ZERO_STRUCTP(r->out.needed);
16107         }
16108         if (flags & NDR_OUT) {
16109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16110                 if (_ptr_info) {
16111                         NDR_PULL_ALLOC(ndr, r->out.info);
16112                 } else {
16113                         r->out.info = NULL;
16114                 }
16115                 if (r->out.info) {
16116                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16117                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16118                         {
16119                                 struct ndr_pull *_ndr_info;
16120                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
16121                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
16122                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
16123                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
16124                         }
16125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16126                 }
16127                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16128                         NDR_PULL_ALLOC(ndr, r->out.needed);
16129                 }
16130                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16131                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16133                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16135         }
16136         return NDR_ERR_SUCCESS;
16137 }
16138
16139 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
16140 {
16141         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
16142         ndr->depth++;
16143         if (flags & NDR_SET_VALUES) {
16144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16145         }
16146         if (flags & NDR_IN) {
16147                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
16148                 ndr->depth++;
16149                 ndr_print_ptr(ndr, "server", r->in.server);
16150                 ndr->depth++;
16151                 if (r->in.server) {
16152                         ndr_print_string(ndr, "server", r->in.server);
16153                 }
16154                 ndr->depth--;
16155                 ndr_print_ptr(ndr, "environment", r->in.environment);
16156                 ndr->depth++;
16157                 if (r->in.environment) {
16158                         ndr_print_string(ndr, "environment", r->in.environment);
16159                 }
16160                 ndr->depth--;
16161                 ndr_print_uint32(ndr, "level", r->in.level);
16162                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16163                 ndr->depth++;
16164                 if (r->in.buffer) {
16165                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16166                 }
16167                 ndr->depth--;
16168                 ndr_print_uint32(ndr, "offered", r->in.offered);
16169                 ndr->depth--;
16170         }
16171         if (flags & NDR_OUT) {
16172                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
16173                 ndr->depth++;
16174                 ndr_print_ptr(ndr, "info", r->out.info);
16175                 ndr->depth++;
16176                 if (r->out.info) {
16177                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16178                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
16179                 }
16180                 ndr->depth--;
16181                 ndr_print_ptr(ndr, "needed", r->out.needed);
16182                 ndr->depth++;
16183                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16184                 ndr->depth--;
16185                 ndr_print_WERROR(ndr, "result", r->out.result);
16186                 ndr->depth--;
16187         }
16188         ndr->depth--;
16189 }
16190
16191 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
16192 {
16193         if (flags & NDR_IN) {
16194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16195                 if (r->in.server) {
16196                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16197                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16199                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16200                 }
16201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16204                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16208                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16209         }
16210         if (flags & NDR_OUT) {
16211                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16212         }
16213         return NDR_ERR_SUCCESS;
16214 }
16215
16216 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
16217 {
16218         uint32_t _ptr_server;
16219         TALLOC_CTX *_mem_save_server_0;
16220         if (flags & NDR_IN) {
16221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16222                 if (_ptr_server) {
16223                         NDR_PULL_ALLOC(ndr, r->in.server);
16224                 } else {
16225                         r->in.server = NULL;
16226                 }
16227                 if (r->in.server) {
16228                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16229                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16230                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16231                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16232                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16233                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
16234                         }
16235                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16236                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16237                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16238                 }
16239                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16240                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16241                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16242                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
16243                 }
16244                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16245                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16246                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
16247                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
16248                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
16249                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.driver), ndr_get_array_length(ndr, &r->in.driver));
16250                 }
16251                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
16252                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
16253         }
16254         if (flags & NDR_OUT) {
16255                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16256         }
16257         return NDR_ERR_SUCCESS;
16258 }
16259
16260 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
16261 {
16262         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
16263         ndr->depth++;
16264         if (flags & NDR_SET_VALUES) {
16265                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16266         }
16267         if (flags & NDR_IN) {
16268                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
16269                 ndr->depth++;
16270                 ndr_print_ptr(ndr, "server", r->in.server);
16271                 ndr->depth++;
16272                 if (r->in.server) {
16273                         ndr_print_string(ndr, "server", r->in.server);
16274                 }
16275                 ndr->depth--;
16276                 ndr_print_string(ndr, "architecture", r->in.architecture);
16277                 ndr_print_string(ndr, "driver", r->in.driver);
16278                 ndr->depth--;
16279         }
16280         if (flags & NDR_OUT) {
16281                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
16282                 ndr->depth++;
16283                 ndr_print_WERROR(ndr, "result", r->out.result);
16284                 ndr->depth--;
16285         }
16286         ndr->depth--;
16287 }
16288
16289 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
16290 {
16291         if (flags & NDR_IN) {
16292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16293                 if (r->in.server) {
16294                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16295                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16297                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16298                 }
16299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16302                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
16306                 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));
16307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
16310                 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));
16311         }
16312         if (flags & NDR_OUT) {
16313                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16314         }
16315         return NDR_ERR_SUCCESS;
16316 }
16317
16318 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
16319 {
16320         uint32_t _ptr_server;
16321         TALLOC_CTX *_mem_save_server_0;
16322         if (flags & NDR_IN) {
16323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16324                 if (_ptr_server) {
16325                         NDR_PULL_ALLOC(ndr, r->in.server);
16326                 } else {
16327                         r->in.server = NULL;
16328                 }
16329                 if (r->in.server) {
16330                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16331                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16332                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16333                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16334                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16335                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
16336                         }
16337                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16338                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16339                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16340                 }
16341                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16342                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16343                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16344                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
16345                 }
16346                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16347                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16348                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
16349                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
16350                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
16351                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.path_name), ndr_get_array_length(ndr, &r->in.path_name));
16352                 }
16353                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
16354                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path_name, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t), CH_UTF16));
16355                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
16356                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
16357                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
16358                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.print_processor_name), ndr_get_array_length(ndr, &r->in.print_processor_name));
16359                 }
16360                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
16361                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.print_processor_name, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t), CH_UTF16));
16362         }
16363         if (flags & NDR_OUT) {
16364                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16365         }
16366         return NDR_ERR_SUCCESS;
16367 }
16368
16369 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
16370 {
16371         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
16372         ndr->depth++;
16373         if (flags & NDR_SET_VALUES) {
16374                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16375         }
16376         if (flags & NDR_IN) {
16377                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
16378                 ndr->depth++;
16379                 ndr_print_ptr(ndr, "server", r->in.server);
16380                 ndr->depth++;
16381                 if (r->in.server) {
16382                         ndr_print_string(ndr, "server", r->in.server);
16383                 }
16384                 ndr->depth--;
16385                 ndr_print_string(ndr, "architecture", r->in.architecture);
16386                 ndr_print_string(ndr, "path_name", r->in.path_name);
16387                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
16388                 ndr->depth--;
16389         }
16390         if (flags & NDR_OUT) {
16391                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
16392                 ndr->depth++;
16393                 ndr_print_WERROR(ndr, "result", r->out.result);
16394                 ndr->depth--;
16395         }
16396         ndr->depth--;
16397 }
16398
16399 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
16400 {
16401         if (flags & NDR_IN) {
16402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
16403                 if (r->in.servername) {
16404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
16407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16408                 }
16409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
16410                 if (r->in.environment) {
16411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
16414                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16415                 }
16416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16417                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16418                 if (r->in.buffer) {
16419                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16420                 }
16421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16422         }
16423         if (flags & NDR_OUT) {
16424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16425                 if (r->out.info) {
16426                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16427                 }
16428                 if (r->out.needed == NULL) {
16429                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16430                 }
16431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16432                 if (r->out.count == NULL) {
16433                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16434                 }
16435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
16436                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16437         }
16438         return NDR_ERR_SUCCESS;
16439 }
16440
16441 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
16442 {
16443         uint32_t _ptr_servername;
16444         uint32_t _ptr_environment;
16445         uint32_t _ptr_buffer;
16446         uint32_t _ptr_info;
16447         TALLOC_CTX *_mem_save_servername_0;
16448         TALLOC_CTX *_mem_save_environment_0;
16449         TALLOC_CTX *_mem_save_buffer_0;
16450         TALLOC_CTX *_mem_save_info_0;
16451         TALLOC_CTX *_mem_save_needed_0;
16452         TALLOC_CTX *_mem_save_count_0;
16453         if (flags & NDR_IN) {
16454                 ZERO_STRUCT(r->out);
16455
16456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
16457                 if (_ptr_servername) {
16458                         NDR_PULL_ALLOC(ndr, r->in.servername);
16459                 } else {
16460                         r->in.servername = NULL;
16461                 }
16462                 if (r->in.servername) {
16463                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16464                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
16465                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
16466                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
16467                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
16468                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
16469                         }
16470                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
16471                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
16472                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
16473                 }
16474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16475                 if (_ptr_environment) {
16476                         NDR_PULL_ALLOC(ndr, r->in.environment);
16477                 } else {
16478                         r->in.environment = NULL;
16479                 }
16480                 if (r->in.environment) {
16481                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16482                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
16483                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
16484                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
16485                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
16486                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
16487                         }
16488                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
16489                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
16490                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16491                 }
16492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16494                 if (_ptr_buffer) {
16495                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16496                 } else {
16497                         r->in.buffer = NULL;
16498                 }
16499                 if (r->in.buffer) {
16500                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16501                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16502                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16504                 }
16505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16506                 NDR_PULL_ALLOC(ndr, r->out.needed);
16507                 ZERO_STRUCTP(r->out.needed);
16508                 NDR_PULL_ALLOC(ndr, r->out.count);
16509                 ZERO_STRUCTP(r->out.count);
16510         }
16511         if (flags & NDR_OUT) {
16512                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16513                 if (_ptr_info) {
16514                         NDR_PULL_ALLOC(ndr, r->out.info);
16515                 } else {
16516                         r->out.info = NULL;
16517                 }
16518                 if (r->out.info) {
16519                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16520                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16521                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16523                 }
16524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16525                         NDR_PULL_ALLOC(ndr, r->out.needed);
16526                 }
16527                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16528                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16530                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16532                         NDR_PULL_ALLOC(ndr, r->out.count);
16533                 }
16534                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16535                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16538                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16539         }
16540         return NDR_ERR_SUCCESS;
16541 }
16542
16543 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
16544 {
16545         uint32_t cntr_info_0;
16546         if (flags & NDR_IN) {
16547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16549         }
16550         if (flags & NDR_OUT) {
16551                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16552                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16553                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16554                 }
16555                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16556                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16557                 }
16558         }
16559         return NDR_ERR_SUCCESS;
16560 }
16561
16562 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
16563 {
16564         uint32_t cntr_info_0;
16565         TALLOC_CTX *_mem_save_info_0;
16566         if (flags & NDR_IN) {
16567                 ZERO_STRUCT(r->out);
16568
16569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16571         }
16572         if (flags & NDR_OUT) {
16573                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16574                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16576                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16577                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16578                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16579                 }
16580                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16581                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16582                 }
16583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16584         }
16585         return NDR_ERR_SUCCESS;
16586 }
16587
16588 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
16589 {
16590         uint32_t cntr_info_1;
16591         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
16592         ndr->depth++;
16593         if (flags & NDR_SET_VALUES) {
16594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16595         }
16596         if (flags & NDR_IN) {
16597                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
16598                 ndr->depth++;
16599                 ndr_print_ptr(ndr, "servername", r->in.servername);
16600                 ndr->depth++;
16601                 if (r->in.servername) {
16602                         ndr_print_string(ndr, "servername", r->in.servername);
16603                 }
16604                 ndr->depth--;
16605                 ndr_print_ptr(ndr, "environment", r->in.environment);
16606                 ndr->depth++;
16607                 if (r->in.environment) {
16608                         ndr_print_string(ndr, "environment", r->in.environment);
16609                 }
16610                 ndr->depth--;
16611                 ndr_print_uint32(ndr, "level", r->in.level);
16612                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16613                 ndr->depth++;
16614                 if (r->in.buffer) {
16615                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16616                 }
16617                 ndr->depth--;
16618                 ndr_print_uint32(ndr, "offered", r->in.offered);
16619                 ndr->depth--;
16620         }
16621         if (flags & NDR_OUT) {
16622                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
16623                 ndr->depth++;
16624                 ndr_print_ptr(ndr, "count", r->out.count);
16625                 ndr->depth++;
16626                 ndr_print_uint32(ndr, "count", *r->out.count);
16627                 ndr->depth--;
16628                 ndr_print_ptr(ndr, "info", r->out.info);
16629                 ndr->depth++;
16630                 if (r->out.info) {
16631                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16632                         ndr->depth++;
16633                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16634                                 char *idx_1=NULL;
16635                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16636                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16637                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
16638                                         free(idx_1);
16639                                 }
16640                         }
16641                         ndr->depth--;
16642                 }
16643                 ndr->depth--;
16644                 ndr_print_ptr(ndr, "needed", r->out.needed);
16645                 ndr->depth++;
16646                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16647                 ndr->depth--;
16648                 ndr_print_WERROR(ndr, "result", r->out.result);
16649                 ndr->depth--;
16650         }
16651         ndr->depth--;
16652 }
16653
16654 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
16655 {
16656         if (flags & NDR_IN) {
16657         }
16658         if (flags & NDR_OUT) {
16659                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16660         }
16661         return NDR_ERR_SUCCESS;
16662 }
16663
16664 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
16665 {
16666         if (flags & NDR_IN) {
16667         }
16668         if (flags & NDR_OUT) {
16669                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16670         }
16671         return NDR_ERR_SUCCESS;
16672 }
16673
16674 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
16675 {
16676         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
16677         ndr->depth++;
16678         if (flags & NDR_SET_VALUES) {
16679                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16680         }
16681         if (flags & NDR_IN) {
16682                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
16683                 ndr->depth++;
16684                 ndr->depth--;
16685         }
16686         if (flags & NDR_OUT) {
16687                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
16688                 ndr->depth++;
16689                 ndr_print_WERROR(ndr, "result", r->out.result);
16690                 ndr->depth--;
16691         }
16692         ndr->depth--;
16693 }
16694
16695 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
16696 {
16697         if (flags & NDR_IN) {
16698                 if (r->in.handle == NULL) {
16699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16700                 }
16701                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16703                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
16704                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16705         }
16706         if (flags & NDR_OUT) {
16707                 if (r->out.job_id == NULL) {
16708                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16709                 }
16710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
16711                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16712         }
16713         return NDR_ERR_SUCCESS;
16714 }
16715
16716 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
16717 {
16718         TALLOC_CTX *_mem_save_handle_0;
16719         TALLOC_CTX *_mem_save_job_id_0;
16720         if (flags & NDR_IN) {
16721                 ZERO_STRUCT(r->out);
16722
16723                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16724                         NDR_PULL_ALLOC(ndr, r->in.handle);
16725                 }
16726                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16727                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16728                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16729                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16731                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
16732                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
16733                 NDR_PULL_ALLOC(ndr, r->out.job_id);
16734                 ZERO_STRUCTP(r->out.job_id);
16735         }
16736         if (flags & NDR_OUT) {
16737                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16738                         NDR_PULL_ALLOC(ndr, r->out.job_id);
16739                 }
16740                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
16741                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
16742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
16743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
16744                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16745         }
16746         return NDR_ERR_SUCCESS;
16747 }
16748
16749 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
16750 {
16751         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
16752         ndr->depth++;
16753         if (flags & NDR_SET_VALUES) {
16754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16755         }
16756         if (flags & NDR_IN) {
16757                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
16758                 ndr->depth++;
16759                 ndr_print_ptr(ndr, "handle", r->in.handle);
16760                 ndr->depth++;
16761                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16762                 ndr->depth--;
16763                 ndr_print_uint32(ndr, "level", r->in.level);
16764                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
16765                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
16766                 ndr->depth--;
16767         }
16768         if (flags & NDR_OUT) {
16769                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
16770                 ndr->depth++;
16771                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
16772                 ndr->depth++;
16773                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
16774                 ndr->depth--;
16775                 ndr_print_WERROR(ndr, "result", r->out.result);
16776                 ndr->depth--;
16777         }
16778         ndr->depth--;
16779 }
16780
16781 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
16782 {
16783         if (flags & NDR_IN) {
16784                 if (r->in.handle == NULL) {
16785                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16786                 }
16787                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16788         }
16789         if (flags & NDR_OUT) {
16790                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16791         }
16792         return NDR_ERR_SUCCESS;
16793 }
16794
16795 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
16796 {
16797         TALLOC_CTX *_mem_save_handle_0;
16798         if (flags & NDR_IN) {
16799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16800                         NDR_PULL_ALLOC(ndr, r->in.handle);
16801                 }
16802                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16804                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16806         }
16807         if (flags & NDR_OUT) {
16808                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16809         }
16810         return NDR_ERR_SUCCESS;
16811 }
16812
16813 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
16814 {
16815         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
16816         ndr->depth++;
16817         if (flags & NDR_SET_VALUES) {
16818                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16819         }
16820         if (flags & NDR_IN) {
16821                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
16822                 ndr->depth++;
16823                 ndr_print_ptr(ndr, "handle", r->in.handle);
16824                 ndr->depth++;
16825                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16826                 ndr->depth--;
16827                 ndr->depth--;
16828         }
16829         if (flags & NDR_OUT) {
16830                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
16831                 ndr->depth++;
16832                 ndr_print_WERROR(ndr, "result", r->out.result);
16833                 ndr->depth--;
16834         }
16835         ndr->depth--;
16836 }
16837
16838 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
16839 {
16840         if (flags & NDR_IN) {
16841                 if (r->in.handle == NULL) {
16842                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16843                 }
16844                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16845                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
16846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
16847         }
16848         if (flags & NDR_OUT) {
16849                 if (r->out.num_written == NULL) {
16850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16851                 }
16852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
16853                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16854         }
16855         return NDR_ERR_SUCCESS;
16856 }
16857
16858 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
16859 {
16860         TALLOC_CTX *_mem_save_handle_0;
16861         TALLOC_CTX *_mem_save_num_written_0;
16862         if (flags & NDR_IN) {
16863                 ZERO_STRUCT(r->out);
16864
16865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16866                         NDR_PULL_ALLOC(ndr, r->in.handle);
16867                 }
16868                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16869                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16870                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16872                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
16873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
16874                 NDR_PULL_ALLOC(ndr, r->out.num_written);
16875                 ZERO_STRUCTP(r->out.num_written);
16876         }
16877         if (flags & NDR_OUT) {
16878                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16879                         NDR_PULL_ALLOC(ndr, r->out.num_written);
16880                 }
16881                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
16882                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
16883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
16884                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
16885                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16886         }
16887         return NDR_ERR_SUCCESS;
16888 }
16889
16890 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
16891 {
16892         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
16893         ndr->depth++;
16894         if (flags & NDR_SET_VALUES) {
16895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16896         }
16897         if (flags & NDR_IN) {
16898                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
16899                 ndr->depth++;
16900                 ndr_print_ptr(ndr, "handle", r->in.handle);
16901                 ndr->depth++;
16902                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16903                 ndr->depth--;
16904                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
16905                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
16906                 ndr->depth--;
16907         }
16908         if (flags & NDR_OUT) {
16909                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
16910                 ndr->depth++;
16911                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
16912                 ndr->depth++;
16913                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
16914                 ndr->depth--;
16915                 ndr_print_WERROR(ndr, "result", r->out.result);
16916                 ndr->depth--;
16917         }
16918         ndr->depth--;
16919 }
16920
16921 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
16922 {
16923         if (flags & NDR_IN) {
16924                 if (r->in.handle == NULL) {
16925                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16926                 }
16927                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16928         }
16929         if (flags & NDR_OUT) {
16930                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16931         }
16932         return NDR_ERR_SUCCESS;
16933 }
16934
16935 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
16936 {
16937         TALLOC_CTX *_mem_save_handle_0;
16938         if (flags & NDR_IN) {
16939                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16940                         NDR_PULL_ALLOC(ndr, r->in.handle);
16941                 }
16942                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16943                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16944                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16945                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16946         }
16947         if (flags & NDR_OUT) {
16948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16949         }
16950         return NDR_ERR_SUCCESS;
16951 }
16952
16953 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
16954 {
16955         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
16956         ndr->depth++;
16957         if (flags & NDR_SET_VALUES) {
16958                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16959         }
16960         if (flags & NDR_IN) {
16961                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
16962                 ndr->depth++;
16963                 ndr_print_ptr(ndr, "handle", r->in.handle);
16964                 ndr->depth++;
16965                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16966                 ndr->depth--;
16967                 ndr->depth--;
16968         }
16969         if (flags & NDR_OUT) {
16970                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
16971                 ndr->depth++;
16972                 ndr_print_WERROR(ndr, "result", r->out.result);
16973                 ndr->depth--;
16974         }
16975         ndr->depth--;
16976 }
16977
16978 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
16979 {
16980         if (flags & NDR_IN) {
16981                 if (r->in.handle == NULL) {
16982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16983                 }
16984                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16985         }
16986         if (flags & NDR_OUT) {
16987                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16988         }
16989         return NDR_ERR_SUCCESS;
16990 }
16991
16992 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
16993 {
16994         TALLOC_CTX *_mem_save_handle_0;
16995         if (flags & NDR_IN) {
16996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16997                         NDR_PULL_ALLOC(ndr, r->in.handle);
16998                 }
16999                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17000                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17001                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17003         }
17004         if (flags & NDR_OUT) {
17005                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17006         }
17007         return NDR_ERR_SUCCESS;
17008 }
17009
17010 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
17011 {
17012         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
17013         ndr->depth++;
17014         if (flags & NDR_SET_VALUES) {
17015                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17016         }
17017         if (flags & NDR_IN) {
17018                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
17019                 ndr->depth++;
17020                 ndr_print_ptr(ndr, "handle", r->in.handle);
17021                 ndr->depth++;
17022                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17023                 ndr->depth--;
17024                 ndr->depth--;
17025         }
17026         if (flags & NDR_OUT) {
17027                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
17028                 ndr->depth++;
17029                 ndr_print_WERROR(ndr, "result", r->out.result);
17030                 ndr->depth--;
17031         }
17032         ndr->depth--;
17033 }
17034
17035 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
17036 {
17037         if (flags & NDR_IN) {
17038                 if (r->in.handle == NULL) {
17039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17040                 }
17041                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17043         }
17044         if (flags & NDR_OUT) {
17045                 if (r->out.data == NULL) {
17046                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17047                 }
17048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
17049                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
17050                 if (r->out._data_size == NULL) {
17051                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17052                 }
17053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
17054                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17055         }
17056         return NDR_ERR_SUCCESS;
17057 }
17058
17059 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
17060 {
17061         TALLOC_CTX *_mem_save_handle_0;
17062         TALLOC_CTX *_mem_save__data_size_0;
17063         if (flags & NDR_IN) {
17064                 ZERO_STRUCT(r->out);
17065
17066                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17067                         NDR_PULL_ALLOC(ndr, r->in.handle);
17068                 }
17069                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17070                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17071                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17072                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
17074                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
17075                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
17076                 NDR_PULL_ALLOC(ndr, r->out._data_size);
17077                 ZERO_STRUCTP(r->out._data_size);
17078         }
17079         if (flags & NDR_OUT) {
17080                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
17081                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17082                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
17083                 }
17084                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
17085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17086                         NDR_PULL_ALLOC(ndr, r->out._data_size);
17087                 }
17088                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
17089                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
17090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
17091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
17092                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17093                 if (r->out.data) {
17094                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
17095                 }
17096         }
17097         return NDR_ERR_SUCCESS;
17098 }
17099
17100 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
17101 {
17102         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
17103         ndr->depth++;
17104         if (flags & NDR_SET_VALUES) {
17105                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17106         }
17107         if (flags & NDR_IN) {
17108                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
17109                 ndr->depth++;
17110                 ndr_print_ptr(ndr, "handle", r->in.handle);
17111                 ndr->depth++;
17112                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17113                 ndr->depth--;
17114                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
17115                 ndr->depth--;
17116         }
17117         if (flags & NDR_OUT) {
17118                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
17119                 ndr->depth++;
17120                 ndr_print_ptr(ndr, "data", r->out.data);
17121                 ndr->depth++;
17122                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
17123                 ndr->depth--;
17124                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
17125                 ndr->depth++;
17126                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
17127                 ndr->depth--;
17128                 ndr_print_WERROR(ndr, "result", r->out.result);
17129                 ndr->depth--;
17130         }
17131         ndr->depth--;
17132 }
17133
17134 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
17135 {
17136         if (flags & NDR_IN) {
17137                 if (r->in.handle == NULL) {
17138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17139                 }
17140                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17141         }
17142         if (flags & NDR_OUT) {
17143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17144         }
17145         return NDR_ERR_SUCCESS;
17146 }
17147
17148 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
17149 {
17150         TALLOC_CTX *_mem_save_handle_0;
17151         if (flags & NDR_IN) {
17152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17153                         NDR_PULL_ALLOC(ndr, r->in.handle);
17154                 }
17155                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17156                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17157                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17159         }
17160         if (flags & NDR_OUT) {
17161                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17162         }
17163         return NDR_ERR_SUCCESS;
17164 }
17165
17166 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
17167 {
17168         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
17169         ndr->depth++;
17170         if (flags & NDR_SET_VALUES) {
17171                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17172         }
17173         if (flags & NDR_IN) {
17174                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
17175                 ndr->depth++;
17176                 ndr_print_ptr(ndr, "handle", r->in.handle);
17177                 ndr->depth++;
17178                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17179                 ndr->depth--;
17180                 ndr->depth--;
17181         }
17182         if (flags & NDR_OUT) {
17183                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
17184                 ndr->depth++;
17185                 ndr_print_WERROR(ndr, "result", r->out.result);
17186                 ndr->depth--;
17187         }
17188         ndr->depth--;
17189 }
17190
17191 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
17192 {
17193         if (flags & NDR_IN) {
17194                 if (r->in.handle == NULL) {
17195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17196                 }
17197                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17199                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17200                 if (r->in.buffer) {
17201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17202                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
17203                 }
17204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17205         }
17206         if (flags & NDR_OUT) {
17207                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
17208                 if (r->out.buffer) {
17209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17210                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
17211                 }
17212                 if (r->out.needed == NULL) {
17213                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17214                 }
17215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17216                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17217         }
17218         return NDR_ERR_SUCCESS;
17219 }
17220
17221 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
17222 {
17223         uint32_t _ptr_buffer;
17224         TALLOC_CTX *_mem_save_handle_0;
17225         TALLOC_CTX *_mem_save_buffer_0;
17226         TALLOC_CTX *_mem_save_needed_0;
17227         if (flags & NDR_IN) {
17228                 ZERO_STRUCT(r->out);
17229
17230                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17231                         NDR_PULL_ALLOC(ndr, r->in.handle);
17232                 }
17233                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17234                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17235                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17238                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17239                 if (_ptr_buffer) {
17240                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17241                 } else {
17242                         r->in.buffer = NULL;
17243                 }
17244                 if (r->in.buffer) {
17245                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17246                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17247                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
17248                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
17249                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
17250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17251                 }
17252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17253                 NDR_PULL_ALLOC(ndr, r->out.needed);
17254                 ZERO_STRUCTP(r->out.needed);
17255                 if (r->in.buffer) {
17256                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
17257                 }
17258         }
17259         if (flags & NDR_OUT) {
17260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17261                 if (_ptr_buffer) {
17262                         NDR_PULL_ALLOC(ndr, r->out.buffer);
17263                 } else {
17264                         r->out.buffer = NULL;
17265                 }
17266                 if (r->out.buffer) {
17267                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17268                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
17269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
17270                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
17271                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
17272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17273                 }
17274                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17275                         NDR_PULL_ALLOC(ndr, r->out.needed);
17276                 }
17277                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17278                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17280                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17281                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17282                 if (r->out.buffer) {
17283                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
17284                 }
17285         }
17286         return NDR_ERR_SUCCESS;
17287 }
17288
17289 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
17290 {
17291         ndr_print_struct(ndr, name, "spoolss_AddJob");
17292         ndr->depth++;
17293         if (flags & NDR_SET_VALUES) {
17294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17295         }
17296         if (flags & NDR_IN) {
17297                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
17298                 ndr->depth++;
17299                 ndr_print_ptr(ndr, "handle", r->in.handle);
17300                 ndr->depth++;
17301                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17302                 ndr->depth--;
17303                 ndr_print_uint32(ndr, "level", r->in.level);
17304                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17305                 ndr->depth++;
17306                 if (r->in.buffer) {
17307                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
17308                 }
17309                 ndr->depth--;
17310                 ndr_print_uint32(ndr, "offered", r->in.offered);
17311                 ndr->depth--;
17312         }
17313         if (flags & NDR_OUT) {
17314                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
17315                 ndr->depth++;
17316                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
17317                 ndr->depth++;
17318                 if (r->out.buffer) {
17319                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
17320                 }
17321                 ndr->depth--;
17322                 ndr_print_ptr(ndr, "needed", r->out.needed);
17323                 ndr->depth++;
17324                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17325                 ndr->depth--;
17326                 ndr_print_WERROR(ndr, "result", r->out.result);
17327                 ndr->depth--;
17328         }
17329         ndr->depth--;
17330 }
17331
17332 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
17333 {
17334         if (flags & NDR_IN) {
17335                 if (r->in.handle == NULL) {
17336                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17337                 }
17338                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
17340         }
17341         if (flags & NDR_OUT) {
17342                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17343         }
17344         return NDR_ERR_SUCCESS;
17345 }
17346
17347 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
17348 {
17349         TALLOC_CTX *_mem_save_handle_0;
17350         if (flags & NDR_IN) {
17351                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17352                         NDR_PULL_ALLOC(ndr, r->in.handle);
17353                 }
17354                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17355                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17356                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17357                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
17359         }
17360         if (flags & NDR_OUT) {
17361                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17362         }
17363         return NDR_ERR_SUCCESS;
17364 }
17365
17366 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
17367 {
17368         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
17369         ndr->depth++;
17370         if (flags & NDR_SET_VALUES) {
17371                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17372         }
17373         if (flags & NDR_IN) {
17374                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
17375                 ndr->depth++;
17376                 ndr_print_ptr(ndr, "handle", r->in.handle);
17377                 ndr->depth++;
17378                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17379                 ndr->depth--;
17380                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
17381                 ndr->depth--;
17382         }
17383         if (flags & NDR_OUT) {
17384                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
17385                 ndr->depth++;
17386                 ndr_print_WERROR(ndr, "result", r->out.result);
17387                 ndr->depth--;
17388         }
17389         ndr->depth--;
17390 }
17391
17392 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
17393 {
17394         if (flags & NDR_IN) {
17395                 if (r->in.handle == NULL) {
17396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17397                 }
17398                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17402                 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));
17403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17404         }
17405         if (flags & NDR_OUT) {
17406                 if (r->out.type == NULL) {
17407                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17408                 }
17409                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
17410                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
17411                 if (r->out.needed == NULL) {
17412                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17413                 }
17414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17415                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17416         }
17417         return NDR_ERR_SUCCESS;
17418 }
17419
17420 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
17421 {
17422         TALLOC_CTX *_mem_save_handle_0;
17423         TALLOC_CTX *_mem_save_type_0;
17424         TALLOC_CTX *_mem_save_needed_0;
17425         if (flags & NDR_IN) {
17426                 ZERO_STRUCT(r->out);
17427
17428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17429                         NDR_PULL_ALLOC(ndr, r->in.handle);
17430                 }
17431                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17432                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17433                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17435                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17436                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17437                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17438                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
17439                 }
17440                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17441                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
17442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17443                 NDR_PULL_ALLOC(ndr, r->out.type);
17444                 ZERO_STRUCTP(r->out.type);
17445                 NDR_PULL_ALLOC(ndr, r->out.needed);
17446                 ZERO_STRUCTP(r->out.needed);
17447         }
17448         if (flags & NDR_OUT) {
17449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17450                         NDR_PULL_ALLOC(ndr, r->out.type);
17451                 }
17452                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
17453                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
17454                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
17455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
17456                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
17457                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17458                         NDR_PULL_ALLOC(ndr, r->out.needed);
17459                 }
17460                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17461                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17464                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17465         }
17466         return NDR_ERR_SUCCESS;
17467 }
17468
17469 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
17470 {
17471         if (flags & NDR_IN) {
17472                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17473         }
17474         if (flags & NDR_OUT) {
17475                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
17476                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17477         }
17478         return NDR_ERR_SUCCESS;
17479 }
17480
17481 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
17482 {
17483         if (flags & NDR_IN) {
17484                 ZERO_STRUCT(r->out);
17485
17486                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
17487         }
17488         if (flags & NDR_OUT) {
17489                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
17490                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17491         }
17492         return NDR_ERR_SUCCESS;
17493 }
17494
17495 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
17496 {
17497         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
17498         ndr->depth++;
17499         if (flags & NDR_SET_VALUES) {
17500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17501         }
17502         if (flags & NDR_IN) {
17503                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
17504                 ndr->depth++;
17505                 ndr_print_ptr(ndr, "handle", r->in.handle);
17506                 ndr->depth++;
17507                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17508                 ndr->depth--;
17509                 ndr_print_string(ndr, "value_name", r->in.value_name);
17510                 ndr_print_uint32(ndr, "offered", r->in.offered);
17511                 ndr->depth--;
17512         }
17513         if (flags & NDR_OUT) {
17514                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
17515                 ndr->depth++;
17516                 ndr_print_ptr(ndr, "type", r->out.type);
17517                 ndr->depth++;
17518                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
17519                 ndr->depth--;
17520                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
17521                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
17522                 ndr_print_ptr(ndr, "needed", r->out.needed);
17523                 ndr->depth++;
17524                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17525                 ndr->depth--;
17526                 ndr_print_WERROR(ndr, "result", r->out.result);
17527                 ndr->depth--;
17528         }
17529         ndr->depth--;
17530 }
17531
17532 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
17533 {
17534         if (flags & NDR_IN) {
17535                 if (r->in.handle == NULL) {
17536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17537                 }
17538                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
17542                 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));
17543                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17544                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
17545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
17546         }
17547         if (flags & NDR_OUT) {
17548                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17549         }
17550         return NDR_ERR_SUCCESS;
17551 }
17552
17553 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
17554 {
17555         if (flags & NDR_IN) {
17556                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
17557         }
17558         if (flags & NDR_OUT) {
17559                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
17560                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
17561         }
17562         return NDR_ERR_SUCCESS;
17563 }
17564
17565 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
17566 {
17567         TALLOC_CTX *_mem_save_handle_0;
17568         if (flags & NDR_IN) {
17569                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17570                         NDR_PULL_ALLOC(ndr, r->in.handle);
17571                 }
17572                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17573                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17574                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17575                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17576                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
17577                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
17578                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
17579                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
17580                 }
17581                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
17582                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
17583                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
17584                 {
17585                         struct ndr_pull *_ndr_data;
17586                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
17587                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
17588                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
17589                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
17590                 }
17591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
17592         }
17593         if (flags & NDR_OUT) {
17594                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17595         }
17596         return NDR_ERR_SUCCESS;
17597 }
17598
17599 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
17600 {
17601         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
17602         ndr->depth++;
17603         if (flags & NDR_SET_VALUES) {
17604                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17605         }
17606         if (flags & NDR_IN) {
17607                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
17608                 ndr->depth++;
17609                 ndr_print_ptr(ndr, "handle", r->in.handle);
17610                 ndr->depth++;
17611                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17612                 ndr->depth--;
17613                 ndr_print_string(ndr, "value_name", r->in.value_name);
17614                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
17615                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
17616                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
17617                 ndr_print_uint32(ndr, "_offered", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(&r->in.data, r->in.type, ndr->iconv_convenience, flags):r->in._offered);
17618                 ndr->depth--;
17619         }
17620         if (flags & NDR_OUT) {
17621                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
17622                 ndr->depth++;
17623                 ndr_print_WERROR(ndr, "result", r->out.result);
17624                 ndr->depth--;
17625         }
17626         ndr->depth--;
17627 }
17628
17629 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
17630 {
17631         if (flags & NDR_IN) {
17632         }
17633         if (flags & NDR_OUT) {
17634                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17635         }
17636         return NDR_ERR_SUCCESS;
17637 }
17638
17639 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
17640 {
17641         if (flags & NDR_IN) {
17642         }
17643         if (flags & NDR_OUT) {
17644                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17645         }
17646         return NDR_ERR_SUCCESS;
17647 }
17648
17649 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
17650 {
17651         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
17652         ndr->depth++;
17653         if (flags & NDR_SET_VALUES) {
17654                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17655         }
17656         if (flags & NDR_IN) {
17657                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
17658                 ndr->depth++;
17659                 ndr->depth--;
17660         }
17661         if (flags & NDR_OUT) {
17662                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
17663                 ndr->depth++;
17664                 ndr_print_WERROR(ndr, "result", r->out.result);
17665                 ndr->depth--;
17666         }
17667         ndr->depth--;
17668 }
17669
17670 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
17671 {
17672         if (flags & NDR_IN) {
17673                 if (r->in.handle == NULL) {
17674                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17675                 }
17676                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17677         }
17678         if (flags & NDR_OUT) {
17679                 if (r->out.handle == NULL) {
17680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17681                 }
17682                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17683                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17684         }
17685         return NDR_ERR_SUCCESS;
17686 }
17687
17688 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
17689 {
17690         TALLOC_CTX *_mem_save_handle_0;
17691         if (flags & NDR_IN) {
17692                 ZERO_STRUCT(r->out);
17693
17694                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17695                         NDR_PULL_ALLOC(ndr, r->in.handle);
17696                 }
17697                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17698                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17699                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17701                 NDR_PULL_ALLOC(ndr, r->out.handle);
17702                 *r->out.handle = *r->in.handle;
17703         }
17704         if (flags & NDR_OUT) {
17705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17706                         NDR_PULL_ALLOC(ndr, r->out.handle);
17707                 }
17708                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17709                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
17710                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17712                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17713         }
17714         return NDR_ERR_SUCCESS;
17715 }
17716
17717 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
17718 {
17719         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
17720         ndr->depth++;
17721         if (flags & NDR_SET_VALUES) {
17722                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17723         }
17724         if (flags & NDR_IN) {
17725                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
17726                 ndr->depth++;
17727                 ndr_print_ptr(ndr, "handle", r->in.handle);
17728                 ndr->depth++;
17729                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17730                 ndr->depth--;
17731                 ndr->depth--;
17732         }
17733         if (flags & NDR_OUT) {
17734                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
17735                 ndr->depth++;
17736                 ndr_print_ptr(ndr, "handle", r->out.handle);
17737                 ndr->depth++;
17738                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
17739                 ndr->depth--;
17740                 ndr_print_WERROR(ndr, "result", r->out.result);
17741                 ndr->depth--;
17742         }
17743         ndr->depth--;
17744 }
17745
17746 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
17747 {
17748         if (flags & NDR_IN) {
17749                 if (r->in.handle == NULL) {
17750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17751                 }
17752                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17754                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
17755                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17756         }
17757         if (flags & NDR_OUT) {
17758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17759         }
17760         return NDR_ERR_SUCCESS;
17761 }
17762
17763 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
17764 {
17765         TALLOC_CTX *_mem_save_handle_0;
17766         if (flags & NDR_IN) {
17767                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17768                         NDR_PULL_ALLOC(ndr, r->in.handle);
17769                 }
17770                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17771                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17772                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17773                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17775                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
17776                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17777         }
17778         if (flags & NDR_OUT) {
17779                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17780         }
17781         return NDR_ERR_SUCCESS;
17782 }
17783
17784 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
17785 {
17786         ndr_print_struct(ndr, name, "spoolss_AddForm");
17787         ndr->depth++;
17788         if (flags & NDR_SET_VALUES) {
17789                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17790         }
17791         if (flags & NDR_IN) {
17792                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
17793                 ndr->depth++;
17794                 ndr_print_ptr(ndr, "handle", r->in.handle);
17795                 ndr->depth++;
17796                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17797                 ndr->depth--;
17798                 ndr_print_uint32(ndr, "level", r->in.level);
17799                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
17800                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
17801                 ndr->depth--;
17802         }
17803         if (flags & NDR_OUT) {
17804                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
17805                 ndr->depth++;
17806                 ndr_print_WERROR(ndr, "result", r->out.result);
17807                 ndr->depth--;
17808         }
17809         ndr->depth--;
17810 }
17811
17812 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
17813 {
17814         if (flags & NDR_IN) {
17815                 if (r->in.handle == NULL) {
17816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17817                 }
17818                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17822                 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));
17823         }
17824         if (flags & NDR_OUT) {
17825                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17826         }
17827         return NDR_ERR_SUCCESS;
17828 }
17829
17830 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
17831 {
17832         TALLOC_CTX *_mem_save_handle_0;
17833         if (flags & NDR_IN) {
17834                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17835                         NDR_PULL_ALLOC(ndr, r->in.handle);
17836                 }
17837                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17838                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17839                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17841                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
17842                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
17843                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
17844                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
17845                 }
17846                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
17847                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
17848         }
17849         if (flags & NDR_OUT) {
17850                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17851         }
17852         return NDR_ERR_SUCCESS;
17853 }
17854
17855 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
17856 {
17857         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
17858         ndr->depth++;
17859         if (flags & NDR_SET_VALUES) {
17860                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17861         }
17862         if (flags & NDR_IN) {
17863                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
17864                 ndr->depth++;
17865                 ndr_print_ptr(ndr, "handle", r->in.handle);
17866                 ndr->depth++;
17867                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17868                 ndr->depth--;
17869                 ndr_print_string(ndr, "form_name", r->in.form_name);
17870                 ndr->depth--;
17871         }
17872         if (flags & NDR_OUT) {
17873                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
17874                 ndr->depth++;
17875                 ndr_print_WERROR(ndr, "result", r->out.result);
17876                 ndr->depth--;
17877         }
17878         ndr->depth--;
17879 }
17880
17881 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
17882 {
17883         if (flags & NDR_IN) {
17884                 if (r->in.handle == NULL) {
17885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17886                 }
17887                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
17891                 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));
17892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17894                 if (r->in.buffer) {
17895                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17896                 }
17897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17898         }
17899         if (flags & NDR_OUT) {
17900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17901                 if (r->out.info) {
17902                         {
17903                                 struct ndr_push *_ndr_info;
17904                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17905                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
17906                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17907                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17908                         }
17909                 }
17910                 if (r->out.needed == NULL) {
17911                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17912                 }
17913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17914                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17915         }
17916         return NDR_ERR_SUCCESS;
17917 }
17918
17919 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
17920 {
17921         uint32_t _ptr_buffer;
17922         uint32_t _ptr_info;
17923         TALLOC_CTX *_mem_save_handle_0;
17924         TALLOC_CTX *_mem_save_buffer_0;
17925         TALLOC_CTX *_mem_save_info_0;
17926         TALLOC_CTX *_mem_save_needed_0;
17927         if (flags & NDR_IN) {
17928                 ZERO_STRUCT(r->out);
17929
17930                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17931                         NDR_PULL_ALLOC(ndr, r->in.handle);
17932                 }
17933                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17934                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17935                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17936                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17937                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
17938                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
17939                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
17940                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
17941                 }
17942                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
17943                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
17944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17945                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17946                 if (_ptr_buffer) {
17947                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17948                 } else {
17949                         r->in.buffer = NULL;
17950                 }
17951                 if (r->in.buffer) {
17952                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17953                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17954                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17956                 }
17957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17958                 NDR_PULL_ALLOC(ndr, r->out.needed);
17959                 ZERO_STRUCTP(r->out.needed);
17960         }
17961         if (flags & NDR_OUT) {
17962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17963                 if (_ptr_info) {
17964                         NDR_PULL_ALLOC(ndr, r->out.info);
17965                 } else {
17966                         r->out.info = NULL;
17967                 }
17968                 if (r->out.info) {
17969                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17970                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17971                         {
17972                                 struct ndr_pull *_ndr_info;
17973                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17974                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
17975                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17976                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17977                         }
17978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17979                 }
17980                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17981                         NDR_PULL_ALLOC(ndr, r->out.needed);
17982                 }
17983                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17984                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17986                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17987                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17988         }
17989         return NDR_ERR_SUCCESS;
17990 }
17991
17992 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
17993 {
17994         ndr_print_struct(ndr, name, "spoolss_GetForm");
17995         ndr->depth++;
17996         if (flags & NDR_SET_VALUES) {
17997                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17998         }
17999         if (flags & NDR_IN) {
18000                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
18001                 ndr->depth++;
18002                 ndr_print_ptr(ndr, "handle", r->in.handle);
18003                 ndr->depth++;
18004                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18005                 ndr->depth--;
18006                 ndr_print_string(ndr, "form_name", r->in.form_name);
18007                 ndr_print_uint32(ndr, "level", r->in.level);
18008                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18009                 ndr->depth++;
18010                 if (r->in.buffer) {
18011                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18012                 }
18013                 ndr->depth--;
18014                 ndr_print_uint32(ndr, "offered", r->in.offered);
18015                 ndr->depth--;
18016         }
18017         if (flags & NDR_OUT) {
18018                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
18019                 ndr->depth++;
18020                 ndr_print_ptr(ndr, "info", r->out.info);
18021                 ndr->depth++;
18022                 if (r->out.info) {
18023                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
18024                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
18025                 }
18026                 ndr->depth--;
18027                 ndr_print_ptr(ndr, "needed", r->out.needed);
18028                 ndr->depth++;
18029                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18030                 ndr->depth--;
18031                 ndr_print_WERROR(ndr, "result", r->out.result);
18032                 ndr->depth--;
18033         }
18034         ndr->depth--;
18035 }
18036
18037 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
18038 {
18039         if (flags & NDR_IN) {
18040                 if (r->in.handle == NULL) {
18041                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18042                 }
18043                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
18047                 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));
18048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18049                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
18050                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18051         }
18052         if (flags & NDR_OUT) {
18053                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18054         }
18055         return NDR_ERR_SUCCESS;
18056 }
18057
18058 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
18059 {
18060         TALLOC_CTX *_mem_save_handle_0;
18061         if (flags & NDR_IN) {
18062                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18063                         NDR_PULL_ALLOC(ndr, r->in.handle);
18064                 }
18065                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18066                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18067                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18068                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18069                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
18070                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
18071                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
18072                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
18073                 }
18074                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
18075                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
18076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18077                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
18078                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
18079         }
18080         if (flags & NDR_OUT) {
18081                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18082         }
18083         return NDR_ERR_SUCCESS;
18084 }
18085
18086 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
18087 {
18088         ndr_print_struct(ndr, name, "spoolss_SetForm");
18089         ndr->depth++;
18090         if (flags & NDR_SET_VALUES) {
18091                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18092         }
18093         if (flags & NDR_IN) {
18094                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
18095                 ndr->depth++;
18096                 ndr_print_ptr(ndr, "handle", r->in.handle);
18097                 ndr->depth++;
18098                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18099                 ndr->depth--;
18100                 ndr_print_string(ndr, "form_name", r->in.form_name);
18101                 ndr_print_uint32(ndr, "level", r->in.level);
18102                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
18103                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
18104                 ndr->depth--;
18105         }
18106         if (flags & NDR_OUT) {
18107                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
18108                 ndr->depth++;
18109                 ndr_print_WERROR(ndr, "result", r->out.result);
18110                 ndr->depth--;
18111         }
18112         ndr->depth--;
18113 }
18114
18115 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
18116 {
18117         if (flags & NDR_IN) {
18118                 if (r->in.handle == NULL) {
18119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18120                 }
18121                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18124                 if (r->in.buffer) {
18125                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18126                 }
18127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18128         }
18129         if (flags & NDR_OUT) {
18130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18131                 if (r->out.info) {
18132                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18133                 }
18134                 if (r->out.needed == NULL) {
18135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18136                 }
18137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18138                 if (r->out.count == NULL) {
18139                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18140                 }
18141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18142                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18143         }
18144         return NDR_ERR_SUCCESS;
18145 }
18146
18147 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
18148 {
18149         uint32_t _ptr_buffer;
18150         uint32_t _ptr_info;
18151         TALLOC_CTX *_mem_save_handle_0;
18152         TALLOC_CTX *_mem_save_buffer_0;
18153         TALLOC_CTX *_mem_save_info_0;
18154         TALLOC_CTX *_mem_save_needed_0;
18155         TALLOC_CTX *_mem_save_count_0;
18156         if (flags & NDR_IN) {
18157                 ZERO_STRUCT(r->out);
18158
18159                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18160                         NDR_PULL_ALLOC(ndr, r->in.handle);
18161                 }
18162                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18163                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18164                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18168                 if (_ptr_buffer) {
18169                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18170                 } else {
18171                         r->in.buffer = NULL;
18172                 }
18173                 if (r->in.buffer) {
18174                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18175                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18176                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18177                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18178                 }
18179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18180                 NDR_PULL_ALLOC(ndr, r->out.needed);
18181                 ZERO_STRUCTP(r->out.needed);
18182                 NDR_PULL_ALLOC(ndr, r->out.count);
18183                 ZERO_STRUCTP(r->out.count);
18184         }
18185         if (flags & NDR_OUT) {
18186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18187                 if (_ptr_info) {
18188                         NDR_PULL_ALLOC(ndr, r->out.info);
18189                 } else {
18190                         r->out.info = NULL;
18191                 }
18192                 if (r->out.info) {
18193                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18194                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18195                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18197                 }
18198                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18199                         NDR_PULL_ALLOC(ndr, r->out.needed);
18200                 }
18201                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18202                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18205                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18206                         NDR_PULL_ALLOC(ndr, r->out.count);
18207                 }
18208                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18209                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18211                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18212                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18213         }
18214         return NDR_ERR_SUCCESS;
18215 }
18216
18217 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
18218 {
18219         uint32_t cntr_info_0;
18220         if (flags & NDR_IN) {
18221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18223         }
18224         if (flags & NDR_OUT) {
18225                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18226                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18227                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18228                 }
18229                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18230                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18231                 }
18232         }
18233         return NDR_ERR_SUCCESS;
18234 }
18235
18236 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
18237 {
18238         uint32_t cntr_info_0;
18239         TALLOC_CTX *_mem_save_info_0;
18240         if (flags & NDR_IN) {
18241                 ZERO_STRUCT(r->out);
18242
18243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18245         }
18246         if (flags & NDR_OUT) {
18247                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18248                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18249                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18250                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18251                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18252                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18253                 }
18254                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18255                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18256                 }
18257                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18258         }
18259         return NDR_ERR_SUCCESS;
18260 }
18261
18262 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
18263 {
18264         uint32_t cntr_info_1;
18265         ndr_print_struct(ndr, name, "spoolss_EnumForms");
18266         ndr->depth++;
18267         if (flags & NDR_SET_VALUES) {
18268                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18269         }
18270         if (flags & NDR_IN) {
18271                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
18272                 ndr->depth++;
18273                 ndr_print_ptr(ndr, "handle", r->in.handle);
18274                 ndr->depth++;
18275                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18276                 ndr->depth--;
18277                 ndr_print_uint32(ndr, "level", r->in.level);
18278                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18279                 ndr->depth++;
18280                 if (r->in.buffer) {
18281                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18282                 }
18283                 ndr->depth--;
18284                 ndr_print_uint32(ndr, "offered", r->in.offered);
18285                 ndr->depth--;
18286         }
18287         if (flags & NDR_OUT) {
18288                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
18289                 ndr->depth++;
18290                 ndr_print_ptr(ndr, "count", r->out.count);
18291                 ndr->depth++;
18292                 ndr_print_uint32(ndr, "count", *r->out.count);
18293                 ndr->depth--;
18294                 ndr_print_ptr(ndr, "info", r->out.info);
18295                 ndr->depth++;
18296                 if (r->out.info) {
18297                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18298                         ndr->depth++;
18299                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18300                                 char *idx_1=NULL;
18301                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18302                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18303                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
18304                                         free(idx_1);
18305                                 }
18306                         }
18307                         ndr->depth--;
18308                 }
18309                 ndr->depth--;
18310                 ndr_print_ptr(ndr, "needed", r->out.needed);
18311                 ndr->depth++;
18312                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18313                 ndr->depth--;
18314                 ndr_print_WERROR(ndr, "result", r->out.result);
18315                 ndr->depth--;
18316         }
18317         ndr->depth--;
18318 }
18319
18320 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
18321 {
18322         if (flags & NDR_IN) {
18323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18324                 if (r->in.servername) {
18325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18328                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18329                 }
18330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18332                 if (r->in.buffer) {
18333                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18334                 }
18335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18336         }
18337         if (flags & NDR_OUT) {
18338                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18339                 if (r->out.info) {
18340                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18341                 }
18342                 if (r->out.needed == NULL) {
18343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18344                 }
18345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18346                 if (r->out.count == NULL) {
18347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18348                 }
18349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18350                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18351         }
18352         return NDR_ERR_SUCCESS;
18353 }
18354
18355 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
18356 {
18357         uint32_t _ptr_servername;
18358         uint32_t _ptr_buffer;
18359         uint32_t _ptr_info;
18360         TALLOC_CTX *_mem_save_servername_0;
18361         TALLOC_CTX *_mem_save_buffer_0;
18362         TALLOC_CTX *_mem_save_info_0;
18363         TALLOC_CTX *_mem_save_needed_0;
18364         TALLOC_CTX *_mem_save_count_0;
18365         if (flags & NDR_IN) {
18366                 ZERO_STRUCT(r->out);
18367
18368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18369                 if (_ptr_servername) {
18370                         NDR_PULL_ALLOC(ndr, r->in.servername);
18371                 } else {
18372                         r->in.servername = NULL;
18373                 }
18374                 if (r->in.servername) {
18375                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18376                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18379                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18380                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
18381                         }
18382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18385                 }
18386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18387                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18388                 if (_ptr_buffer) {
18389                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18390                 } else {
18391                         r->in.buffer = NULL;
18392                 }
18393                 if (r->in.buffer) {
18394                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18395                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18396                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18398                 }
18399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18400                 NDR_PULL_ALLOC(ndr, r->out.needed);
18401                 ZERO_STRUCTP(r->out.needed);
18402                 NDR_PULL_ALLOC(ndr, r->out.count);
18403                 ZERO_STRUCTP(r->out.count);
18404         }
18405         if (flags & NDR_OUT) {
18406                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18407                 if (_ptr_info) {
18408                         NDR_PULL_ALLOC(ndr, r->out.info);
18409                 } else {
18410                         r->out.info = NULL;
18411                 }
18412                 if (r->out.info) {
18413                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18414                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18415                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18416                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18417                 }
18418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18419                         NDR_PULL_ALLOC(ndr, r->out.needed);
18420                 }
18421                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18422                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18426                         NDR_PULL_ALLOC(ndr, r->out.count);
18427                 }
18428                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18429                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18432                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18433         }
18434         return NDR_ERR_SUCCESS;
18435 }
18436
18437 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
18438 {
18439         uint32_t cntr_info_0;
18440         if (flags & NDR_IN) {
18441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18443         }
18444         if (flags & NDR_OUT) {
18445                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18446                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18447                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18448                 }
18449                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18450                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18451                 }
18452         }
18453         return NDR_ERR_SUCCESS;
18454 }
18455
18456 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
18457 {
18458         uint32_t cntr_info_0;
18459         TALLOC_CTX *_mem_save_info_0;
18460         if (flags & NDR_IN) {
18461                 ZERO_STRUCT(r->out);
18462
18463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18465         }
18466         if (flags & NDR_OUT) {
18467                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18468                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18469                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18470                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18471                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18472                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18473                 }
18474                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18475                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18476                 }
18477                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18478         }
18479         return NDR_ERR_SUCCESS;
18480 }
18481
18482 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
18483 {
18484         uint32_t cntr_info_1;
18485         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
18486         ndr->depth++;
18487         if (flags & NDR_SET_VALUES) {
18488                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18489         }
18490         if (flags & NDR_IN) {
18491                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
18492                 ndr->depth++;
18493                 ndr_print_ptr(ndr, "servername", r->in.servername);
18494                 ndr->depth++;
18495                 if (r->in.servername) {
18496                         ndr_print_string(ndr, "servername", r->in.servername);
18497                 }
18498                 ndr->depth--;
18499                 ndr_print_uint32(ndr, "level", r->in.level);
18500                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18501                 ndr->depth++;
18502                 if (r->in.buffer) {
18503                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18504                 }
18505                 ndr->depth--;
18506                 ndr_print_uint32(ndr, "offered", r->in.offered);
18507                 ndr->depth--;
18508         }
18509         if (flags & NDR_OUT) {
18510                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
18511                 ndr->depth++;
18512                 ndr_print_ptr(ndr, "count", r->out.count);
18513                 ndr->depth++;
18514                 ndr_print_uint32(ndr, "count", *r->out.count);
18515                 ndr->depth--;
18516                 ndr_print_ptr(ndr, "info", r->out.info);
18517                 ndr->depth++;
18518                 if (r->out.info) {
18519                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18520                         ndr->depth++;
18521                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18522                                 char *idx_1=NULL;
18523                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18524                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18525                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
18526                                         free(idx_1);
18527                                 }
18528                         }
18529                         ndr->depth--;
18530                 }
18531                 ndr->depth--;
18532                 ndr_print_ptr(ndr, "needed", r->out.needed);
18533                 ndr->depth++;
18534                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18535                 ndr->depth--;
18536                 ndr_print_WERROR(ndr, "result", r->out.result);
18537                 ndr->depth--;
18538         }
18539         ndr->depth--;
18540 }
18541
18542 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
18543 {
18544         if (flags & NDR_IN) {
18545                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18546                 if (r->in.servername) {
18547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18550                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18551                 }
18552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18554                 if (r->in.buffer) {
18555                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18556                 }
18557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18558         }
18559         if (flags & NDR_OUT) {
18560                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18561                 if (r->out.info) {
18562                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18563                 }
18564                 if (r->out.needed == NULL) {
18565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18566                 }
18567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18568                 if (r->out.count == NULL) {
18569                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18570                 }
18571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18572                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18573         }
18574         return NDR_ERR_SUCCESS;
18575 }
18576
18577 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
18578 {
18579         uint32_t _ptr_servername;
18580         uint32_t _ptr_buffer;
18581         uint32_t _ptr_info;
18582         TALLOC_CTX *_mem_save_servername_0;
18583         TALLOC_CTX *_mem_save_buffer_0;
18584         TALLOC_CTX *_mem_save_info_0;
18585         TALLOC_CTX *_mem_save_needed_0;
18586         TALLOC_CTX *_mem_save_count_0;
18587         if (flags & NDR_IN) {
18588                 ZERO_STRUCT(r->out);
18589
18590                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18591                 if (_ptr_servername) {
18592                         NDR_PULL_ALLOC(ndr, r->in.servername);
18593                 } else {
18594                         r->in.servername = NULL;
18595                 }
18596                 if (r->in.servername) {
18597                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18598                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18599                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18600                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18601                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18602                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
18603                         }
18604                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18605                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18606                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18607                 }
18608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18609                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18610                 if (_ptr_buffer) {
18611                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18612                 } else {
18613                         r->in.buffer = NULL;
18614                 }
18615                 if (r->in.buffer) {
18616                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18617                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18618                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18620                 }
18621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18622                 NDR_PULL_ALLOC(ndr, r->out.needed);
18623                 ZERO_STRUCTP(r->out.needed);
18624                 NDR_PULL_ALLOC(ndr, r->out.count);
18625                 ZERO_STRUCTP(r->out.count);
18626         }
18627         if (flags & NDR_OUT) {
18628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18629                 if (_ptr_info) {
18630                         NDR_PULL_ALLOC(ndr, r->out.info);
18631                 } else {
18632                         r->out.info = NULL;
18633                 }
18634                 if (r->out.info) {
18635                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18636                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18637                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18639                 }
18640                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18641                         NDR_PULL_ALLOC(ndr, r->out.needed);
18642                 }
18643                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18644                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18646                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18647                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18648                         NDR_PULL_ALLOC(ndr, r->out.count);
18649                 }
18650                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18651                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18653                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18655         }
18656         return NDR_ERR_SUCCESS;
18657 }
18658
18659 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
18660 {
18661         uint32_t cntr_info_0;
18662         if (flags & NDR_IN) {
18663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18665         }
18666         if (flags & NDR_OUT) {
18667                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18668                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18669                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18670                 }
18671                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18672                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18673                 }
18674         }
18675         return NDR_ERR_SUCCESS;
18676 }
18677
18678 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
18679 {
18680         uint32_t cntr_info_0;
18681         TALLOC_CTX *_mem_save_info_0;
18682         if (flags & NDR_IN) {
18683                 ZERO_STRUCT(r->out);
18684
18685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18687         }
18688         if (flags & NDR_OUT) {
18689                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18690                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18691                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18692                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18693                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18694                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18695                 }
18696                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18697                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18698                 }
18699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18700         }
18701         return NDR_ERR_SUCCESS;
18702 }
18703
18704 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
18705 {
18706         uint32_t cntr_info_1;
18707         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
18708         ndr->depth++;
18709         if (flags & NDR_SET_VALUES) {
18710                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18711         }
18712         if (flags & NDR_IN) {
18713                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
18714                 ndr->depth++;
18715                 ndr_print_ptr(ndr, "servername", r->in.servername);
18716                 ndr->depth++;
18717                 if (r->in.servername) {
18718                         ndr_print_string(ndr, "servername", r->in.servername);
18719                 }
18720                 ndr->depth--;
18721                 ndr_print_uint32(ndr, "level", r->in.level);
18722                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18723                 ndr->depth++;
18724                 if (r->in.buffer) {
18725                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18726                 }
18727                 ndr->depth--;
18728                 ndr_print_uint32(ndr, "offered", r->in.offered);
18729                 ndr->depth--;
18730         }
18731         if (flags & NDR_OUT) {
18732                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
18733                 ndr->depth++;
18734                 ndr_print_ptr(ndr, "count", r->out.count);
18735                 ndr->depth++;
18736                 ndr_print_uint32(ndr, "count", *r->out.count);
18737                 ndr->depth--;
18738                 ndr_print_ptr(ndr, "info", r->out.info);
18739                 ndr->depth++;
18740                 if (r->out.info) {
18741                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18742                         ndr->depth++;
18743                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18744                                 char *idx_1=NULL;
18745                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18746                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18747                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
18748                                         free(idx_1);
18749                                 }
18750                         }
18751                         ndr->depth--;
18752                 }
18753                 ndr->depth--;
18754                 ndr_print_ptr(ndr, "needed", r->out.needed);
18755                 ndr->depth++;
18756                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18757                 ndr->depth--;
18758                 ndr_print_WERROR(ndr, "result", r->out.result);
18759                 ndr->depth--;
18760         }
18761         ndr->depth--;
18762 }
18763
18764 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
18765 {
18766         if (flags & NDR_IN) {
18767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
18768                 if (r->in.server_name) {
18769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
18770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
18772                         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));
18773                 }
18774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
18775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
18776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
18778                 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));
18779         }
18780         if (flags & NDR_OUT) {
18781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18782         }
18783         return NDR_ERR_SUCCESS;
18784 }
18785
18786 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
18787 {
18788         uint32_t _ptr_server_name;
18789         TALLOC_CTX *_mem_save_server_name_0;
18790         if (flags & NDR_IN) {
18791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
18792                 if (_ptr_server_name) {
18793                         NDR_PULL_ALLOC(ndr, r->in.server_name);
18794                 } else {
18795                         r->in.server_name = NULL;
18796                 }
18797                 if (r->in.server_name) {
18798                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18799                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
18800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
18801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
18802                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
18803                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
18804                         }
18805                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
18806                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
18807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
18808                 }
18809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
18810                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
18811                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
18812                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
18813                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.monitor_name), ndr_get_array_length(ndr, &r->in.monitor_name));
18814                 }
18815                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
18816                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.monitor_name, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t), CH_UTF16));
18817         }
18818         if (flags & NDR_OUT) {
18819                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18820         }
18821         return NDR_ERR_SUCCESS;
18822 }
18823
18824 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
18825 {
18826         ndr_print_struct(ndr, name, "spoolss_AddPort");
18827         ndr->depth++;
18828         if (flags & NDR_SET_VALUES) {
18829                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18830         }
18831         if (flags & NDR_IN) {
18832                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
18833                 ndr->depth++;
18834                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
18835                 ndr->depth++;
18836                 if (r->in.server_name) {
18837                         ndr_print_string(ndr, "server_name", r->in.server_name);
18838                 }
18839                 ndr->depth--;
18840                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
18841                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
18842                 ndr->depth--;
18843         }
18844         if (flags & NDR_OUT) {
18845                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
18846                 ndr->depth++;
18847                 ndr_print_WERROR(ndr, "result", r->out.result);
18848                 ndr->depth--;
18849         }
18850         ndr->depth--;
18851 }
18852
18853 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
18854 {
18855         if (flags & NDR_IN) {
18856         }
18857         if (flags & NDR_OUT) {
18858                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18859         }
18860         return NDR_ERR_SUCCESS;
18861 }
18862
18863 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
18864 {
18865         if (flags & NDR_IN) {
18866         }
18867         if (flags & NDR_OUT) {
18868                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18869         }
18870         return NDR_ERR_SUCCESS;
18871 }
18872
18873 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
18874 {
18875         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
18876         ndr->depth++;
18877         if (flags & NDR_SET_VALUES) {
18878                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18879         }
18880         if (flags & NDR_IN) {
18881                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
18882                 ndr->depth++;
18883                 ndr->depth--;
18884         }
18885         if (flags & NDR_OUT) {
18886                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
18887                 ndr->depth++;
18888                 ndr_print_WERROR(ndr, "result", r->out.result);
18889                 ndr->depth--;
18890         }
18891         ndr->depth--;
18892 }
18893
18894 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
18895 {
18896         if (flags & NDR_IN) {
18897         }
18898         if (flags & NDR_OUT) {
18899                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18900         }
18901         return NDR_ERR_SUCCESS;
18902 }
18903
18904 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
18905 {
18906         if (flags & NDR_IN) {
18907         }
18908         if (flags & NDR_OUT) {
18909                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18910         }
18911         return NDR_ERR_SUCCESS;
18912 }
18913
18914 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
18915 {
18916         ndr_print_struct(ndr, name, "spoolss_DeletePort");
18917         ndr->depth++;
18918         if (flags & NDR_SET_VALUES) {
18919                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18920         }
18921         if (flags & NDR_IN) {
18922                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
18923                 ndr->depth++;
18924                 ndr->depth--;
18925         }
18926         if (flags & NDR_OUT) {
18927                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
18928                 ndr->depth++;
18929                 ndr_print_WERROR(ndr, "result", r->out.result);
18930                 ndr->depth--;
18931         }
18932         ndr->depth--;
18933 }
18934
18935 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
18936 {
18937         if (flags & NDR_IN) {
18938         }
18939         if (flags & NDR_OUT) {
18940                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18941         }
18942         return NDR_ERR_SUCCESS;
18943 }
18944
18945 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
18946 {
18947         if (flags & NDR_IN) {
18948         }
18949         if (flags & NDR_OUT) {
18950                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18951         }
18952         return NDR_ERR_SUCCESS;
18953 }
18954
18955 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
18956 {
18957         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
18958         ndr->depth++;
18959         if (flags & NDR_SET_VALUES) {
18960                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18961         }
18962         if (flags & NDR_IN) {
18963                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
18964                 ndr->depth++;
18965                 ndr->depth--;
18966         }
18967         if (flags & NDR_OUT) {
18968                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
18969                 ndr->depth++;
18970                 ndr_print_WERROR(ndr, "result", r->out.result);
18971                 ndr->depth--;
18972         }
18973         ndr->depth--;
18974 }
18975
18976 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
18977 {
18978         if (flags & NDR_IN) {
18979         }
18980         if (flags & NDR_OUT) {
18981                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18982         }
18983         return NDR_ERR_SUCCESS;
18984 }
18985
18986 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
18987 {
18988         if (flags & NDR_IN) {
18989         }
18990         if (flags & NDR_OUT) {
18991                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18992         }
18993         return NDR_ERR_SUCCESS;
18994 }
18995
18996 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
18997 {
18998         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
18999         ndr->depth++;
19000         if (flags & NDR_SET_VALUES) {
19001                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19002         }
19003         if (flags & NDR_IN) {
19004                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
19005                 ndr->depth++;
19006                 ndr->depth--;
19007         }
19008         if (flags & NDR_OUT) {
19009                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
19010                 ndr->depth++;
19011                 ndr_print_WERROR(ndr, "result", r->out.result);
19012                 ndr->depth--;
19013         }
19014         ndr->depth--;
19015 }
19016
19017 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
19018 {
19019         if (flags & NDR_IN) {
19020         }
19021         if (flags & NDR_OUT) {
19022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19023         }
19024         return NDR_ERR_SUCCESS;
19025 }
19026
19027 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
19028 {
19029         if (flags & NDR_IN) {
19030         }
19031         if (flags & NDR_OUT) {
19032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19033         }
19034         return NDR_ERR_SUCCESS;
19035 }
19036
19037 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
19038 {
19039         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
19040         ndr->depth++;
19041         if (flags & NDR_SET_VALUES) {
19042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19043         }
19044         if (flags & NDR_IN) {
19045                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
19046                 ndr->depth++;
19047                 ndr->depth--;
19048         }
19049         if (flags & NDR_OUT) {
19050                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
19051                 ndr->depth++;
19052                 ndr_print_WERROR(ndr, "result", r->out.result);
19053                 ndr->depth--;
19054         }
19055         ndr->depth--;
19056 }
19057
19058 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
19059 {
19060         if (flags & NDR_IN) {
19061         }
19062         if (flags & NDR_OUT) {
19063                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19064         }
19065         return NDR_ERR_SUCCESS;
19066 }
19067
19068 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
19069 {
19070         if (flags & NDR_IN) {
19071         }
19072         if (flags & NDR_OUT) {
19073                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19074         }
19075         return NDR_ERR_SUCCESS;
19076 }
19077
19078 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
19079 {
19080         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
19081         ndr->depth++;
19082         if (flags & NDR_SET_VALUES) {
19083                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19084         }
19085         if (flags & NDR_IN) {
19086                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
19087                 ndr->depth++;
19088                 ndr->depth--;
19089         }
19090         if (flags & NDR_OUT) {
19091                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
19092                 ndr->depth++;
19093                 ndr_print_WERROR(ndr, "result", r->out.result);
19094                 ndr->depth--;
19095         }
19096         ndr->depth--;
19097 }
19098
19099 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
19100 {
19101         if (flags & NDR_IN) {
19102         }
19103         if (flags & NDR_OUT) {
19104                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19105         }
19106         return NDR_ERR_SUCCESS;
19107 }
19108
19109 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
19110 {
19111         if (flags & NDR_IN) {
19112         }
19113         if (flags & NDR_OUT) {
19114                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19115         }
19116         return NDR_ERR_SUCCESS;
19117 }
19118
19119 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
19120 {
19121         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
19122         ndr->depth++;
19123         if (flags & NDR_SET_VALUES) {
19124                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19125         }
19126         if (flags & NDR_IN) {
19127                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
19128                 ndr->depth++;
19129                 ndr->depth--;
19130         }
19131         if (flags & NDR_OUT) {
19132                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
19133                 ndr->depth++;
19134                 ndr_print_WERROR(ndr, "result", r->out.result);
19135                 ndr->depth--;
19136         }
19137         ndr->depth--;
19138 }
19139
19140 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
19141 {
19142         if (flags & NDR_IN) {
19143         }
19144         if (flags & NDR_OUT) {
19145                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19146         }
19147         return NDR_ERR_SUCCESS;
19148 }
19149
19150 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
19151 {
19152         if (flags & NDR_IN) {
19153         }
19154         if (flags & NDR_OUT) {
19155                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19156         }
19157         return NDR_ERR_SUCCESS;
19158 }
19159
19160 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
19161 {
19162         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
19163         ndr->depth++;
19164         if (flags & NDR_SET_VALUES) {
19165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19166         }
19167         if (flags & NDR_IN) {
19168                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
19169                 ndr->depth++;
19170                 ndr->depth--;
19171         }
19172         if (flags & NDR_OUT) {
19173                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
19174                 ndr->depth++;
19175                 ndr_print_WERROR(ndr, "result", r->out.result);
19176                 ndr->depth--;
19177         }
19178         ndr->depth--;
19179 }
19180
19181 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
19182 {
19183         if (flags & NDR_IN) {
19184         }
19185         if (flags & NDR_OUT) {
19186                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19187         }
19188         return NDR_ERR_SUCCESS;
19189 }
19190
19191 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
19192 {
19193         if (flags & NDR_IN) {
19194         }
19195         if (flags & NDR_OUT) {
19196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19197         }
19198         return NDR_ERR_SUCCESS;
19199 }
19200
19201 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
19202 {
19203         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
19204         ndr->depth++;
19205         if (flags & NDR_SET_VALUES) {
19206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19207         }
19208         if (flags & NDR_IN) {
19209                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
19210                 ndr->depth++;
19211                 ndr->depth--;
19212         }
19213         if (flags & NDR_OUT) {
19214                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
19215                 ndr->depth++;
19216                 ndr_print_WERROR(ndr, "result", r->out.result);
19217                 ndr->depth--;
19218         }
19219         ndr->depth--;
19220 }
19221
19222 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
19223 {
19224         if (flags & NDR_IN) {
19225         }
19226         if (flags & NDR_OUT) {
19227                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19228         }
19229         return NDR_ERR_SUCCESS;
19230 }
19231
19232 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
19233 {
19234         if (flags & NDR_IN) {
19235         }
19236         if (flags & NDR_OUT) {
19237                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19238         }
19239         return NDR_ERR_SUCCESS;
19240 }
19241
19242 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
19243 {
19244         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
19245         ndr->depth++;
19246         if (flags & NDR_SET_VALUES) {
19247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19248         }
19249         if (flags & NDR_IN) {
19250                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
19251                 ndr->depth++;
19252                 ndr->depth--;
19253         }
19254         if (flags & NDR_OUT) {
19255                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
19256                 ndr->depth++;
19257                 ndr_print_WERROR(ndr, "result", r->out.result);
19258                 ndr->depth--;
19259         }
19260         ndr->depth--;
19261 }
19262
19263 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
19264 {
19265         if (flags & NDR_IN) {
19266         }
19267         if (flags & NDR_OUT) {
19268                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19269         }
19270         return NDR_ERR_SUCCESS;
19271 }
19272
19273 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
19274 {
19275         if (flags & NDR_IN) {
19276         }
19277         if (flags & NDR_OUT) {
19278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19279         }
19280         return NDR_ERR_SUCCESS;
19281 }
19282
19283 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
19284 {
19285         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
19286         ndr->depth++;
19287         if (flags & NDR_SET_VALUES) {
19288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19289         }
19290         if (flags & NDR_IN) {
19291                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
19292                 ndr->depth++;
19293                 ndr->depth--;
19294         }
19295         if (flags & NDR_OUT) {
19296                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
19297                 ndr->depth++;
19298                 ndr_print_WERROR(ndr, "result", r->out.result);
19299                 ndr->depth--;
19300         }
19301         ndr->depth--;
19302 }
19303
19304 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
19305 {
19306         if (flags & NDR_IN) {
19307         }
19308         if (flags & NDR_OUT) {
19309                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19310         }
19311         return NDR_ERR_SUCCESS;
19312 }
19313
19314 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
19315 {
19316         if (flags & NDR_IN) {
19317         }
19318         if (flags & NDR_OUT) {
19319                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19320         }
19321         return NDR_ERR_SUCCESS;
19322 }
19323
19324 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
19325 {
19326         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
19327         ndr->depth++;
19328         if (flags & NDR_SET_VALUES) {
19329                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19330         }
19331         if (flags & NDR_IN) {
19332                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
19333                 ndr->depth++;
19334                 ndr->depth--;
19335         }
19336         if (flags & NDR_OUT) {
19337                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
19338                 ndr->depth++;
19339                 ndr_print_WERROR(ndr, "result", r->out.result);
19340                 ndr->depth--;
19341         }
19342         ndr->depth--;
19343 }
19344
19345 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
19346 {
19347         if (flags & NDR_IN) {
19348         }
19349         if (flags & NDR_OUT) {
19350                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19351         }
19352         return NDR_ERR_SUCCESS;
19353 }
19354
19355 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
19356 {
19357         if (flags & NDR_IN) {
19358         }
19359         if (flags & NDR_OUT) {
19360                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19361         }
19362         return NDR_ERR_SUCCESS;
19363 }
19364
19365 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
19366 {
19367         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
19368         ndr->depth++;
19369         if (flags & NDR_SET_VALUES) {
19370                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19371         }
19372         if (flags & NDR_IN) {
19373                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
19374                 ndr->depth++;
19375                 ndr->depth--;
19376         }
19377         if (flags & NDR_OUT) {
19378                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
19379                 ndr->depth++;
19380                 ndr_print_WERROR(ndr, "result", r->out.result);
19381                 ndr->depth--;
19382         }
19383         ndr->depth--;
19384 }
19385
19386 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19387 {
19388         if (flags & NDR_IN) {
19389         }
19390         if (flags & NDR_OUT) {
19391                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19392         }
19393         return NDR_ERR_SUCCESS;
19394 }
19395
19396 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
19397 {
19398         if (flags & NDR_IN) {
19399         }
19400         if (flags & NDR_OUT) {
19401                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19402         }
19403         return NDR_ERR_SUCCESS;
19404 }
19405
19406 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
19407 {
19408         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
19409         ndr->depth++;
19410         if (flags & NDR_SET_VALUES) {
19411                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19412         }
19413         if (flags & NDR_IN) {
19414                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
19415                 ndr->depth++;
19416                 ndr->depth--;
19417         }
19418         if (flags & NDR_OUT) {
19419                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
19420                 ndr->depth++;
19421                 ndr_print_WERROR(ndr, "result", r->out.result);
19422                 ndr->depth--;
19423         }
19424         ndr->depth--;
19425 }
19426
19427 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
19428 {
19429         if (flags & NDR_IN) {
19430                 if (r->in.handle == NULL) {
19431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19432                 }
19433                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
19435                 if (r->in.data_type) {
19436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
19439                         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));
19440                 }
19441                 if (r->in.devmode_ctr == NULL) {
19442                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19443                 }
19444                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19445         }
19446         if (flags & NDR_OUT) {
19447                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19448         }
19449         return NDR_ERR_SUCCESS;
19450 }
19451
19452 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
19453 {
19454         uint32_t _ptr_data_type;
19455         TALLOC_CTX *_mem_save_handle_0;
19456         TALLOC_CTX *_mem_save_data_type_0;
19457         TALLOC_CTX *_mem_save_devmode_ctr_0;
19458         if (flags & NDR_IN) {
19459                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19460                         NDR_PULL_ALLOC(ndr, r->in.handle);
19461                 }
19462                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19463                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19464                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19465                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
19467                 if (_ptr_data_type) {
19468                         NDR_PULL_ALLOC(ndr, r->in.data_type);
19469                 } else {
19470                         r->in.data_type = NULL;
19471                 }
19472                 if (r->in.data_type) {
19473                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
19474                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
19475                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
19476                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
19477                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
19478                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.data_type), ndr_get_array_length(ndr, &r->in.data_type));
19479                         }
19480                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
19481                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.data_type, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t), CH_UTF16));
19482                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
19483                 }
19484                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19485                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19486                 }
19487                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19488                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19489                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19491         }
19492         if (flags & NDR_OUT) {
19493                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19494         }
19495         return NDR_ERR_SUCCESS;
19496 }
19497
19498 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
19499 {
19500         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
19501         ndr->depth++;
19502         if (flags & NDR_SET_VALUES) {
19503                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19504         }
19505         if (flags & NDR_IN) {
19506                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
19507                 ndr->depth++;
19508                 ndr_print_ptr(ndr, "handle", r->in.handle);
19509                 ndr->depth++;
19510                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19511                 ndr->depth--;
19512                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
19513                 ndr->depth++;
19514                 if (r->in.data_type) {
19515                         ndr_print_string(ndr, "data_type", r->in.data_type);
19516                 }
19517                 ndr->depth--;
19518                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19519                 ndr->depth++;
19520                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19521                 ndr->depth--;
19522                 ndr->depth--;
19523         }
19524         if (flags & NDR_OUT) {
19525                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
19526                 ndr->depth++;
19527                 ndr_print_WERROR(ndr, "result", r->out.result);
19528                 ndr->depth--;
19529         }
19530         ndr->depth--;
19531 }
19532
19533 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
19534 {
19535         if (flags & NDR_IN) {
19536                 if (r->in.handle == NULL) {
19537                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19538                 }
19539                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
19541                 if (r->in.architecture) {
19542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19546                 }
19547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19549                 if (r->in.buffer) {
19550                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19551                 }
19552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
19554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
19555         }
19556         if (flags & NDR_OUT) {
19557                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19558                 if (r->out.info) {
19559                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19560                 }
19561                 if (r->out.needed == NULL) {
19562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19563                 }
19564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19565                 if (r->out.server_major_version == NULL) {
19566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19567                 }
19568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
19569                 if (r->out.server_minor_version == NULL) {
19570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19571                 }
19572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
19573                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19574         }
19575         return NDR_ERR_SUCCESS;
19576 }
19577
19578 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
19579 {
19580         uint32_t _ptr_architecture;
19581         uint32_t _ptr_buffer;
19582         uint32_t _ptr_info;
19583         TALLOC_CTX *_mem_save_handle_0;
19584         TALLOC_CTX *_mem_save_architecture_0;
19585         TALLOC_CTX *_mem_save_buffer_0;
19586         TALLOC_CTX *_mem_save_info_0;
19587         TALLOC_CTX *_mem_save_needed_0;
19588         TALLOC_CTX *_mem_save_server_major_version_0;
19589         TALLOC_CTX *_mem_save_server_minor_version_0;
19590         if (flags & NDR_IN) {
19591                 ZERO_STRUCT(r->out);
19592
19593                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19594                         NDR_PULL_ALLOC(ndr, r->in.handle);
19595                 }
19596                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19597                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19598                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19600                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
19601                 if (_ptr_architecture) {
19602                         NDR_PULL_ALLOC(ndr, r->in.architecture);
19603                 } else {
19604                         r->in.architecture = NULL;
19605                 }
19606                 if (r->in.architecture) {
19607                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
19608                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
19609                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
19610                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
19611                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
19612                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
19613                         }
19614                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
19615                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
19616                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
19617                 }
19618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19620                 if (_ptr_buffer) {
19621                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19622                 } else {
19623                         r->in.buffer = NULL;
19624                 }
19625                 if (r->in.buffer) {
19626                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19627                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19628                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19630                 }
19631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
19633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
19634                 NDR_PULL_ALLOC(ndr, r->out.needed);
19635                 ZERO_STRUCTP(r->out.needed);
19636                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
19637                 ZERO_STRUCTP(r->out.server_major_version);
19638                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
19639                 ZERO_STRUCTP(r->out.server_minor_version);
19640         }
19641         if (flags & NDR_OUT) {
19642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19643                 if (_ptr_info) {
19644                         NDR_PULL_ALLOC(ndr, r->out.info);
19645                 } else {
19646                         r->out.info = NULL;
19647                 }
19648                 if (r->out.info) {
19649                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19650                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19651                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19653                 }
19654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19655                         NDR_PULL_ALLOC(ndr, r->out.needed);
19656                 }
19657                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19658                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19662                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
19663                 }
19664                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
19665                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
19666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
19667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
19668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19669                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
19670                 }
19671                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
19672                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
19673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
19674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
19675                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19676         }
19677         return NDR_ERR_SUCCESS;
19678 }
19679
19680 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
19681 {
19682         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
19683         ndr->depth++;
19684         if (flags & NDR_SET_VALUES) {
19685                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19686         }
19687         if (flags & NDR_IN) {
19688                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
19689                 ndr->depth++;
19690                 ndr_print_ptr(ndr, "handle", r->in.handle);
19691                 ndr->depth++;
19692                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19693                 ndr->depth--;
19694                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
19695                 ndr->depth++;
19696                 if (r->in.architecture) {
19697                         ndr_print_string(ndr, "architecture", r->in.architecture);
19698                 }
19699                 ndr->depth--;
19700                 ndr_print_uint32(ndr, "level", r->in.level);
19701                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19702                 ndr->depth++;
19703                 if (r->in.buffer) {
19704                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19705                 }
19706                 ndr->depth--;
19707                 ndr_print_uint32(ndr, "offered", r->in.offered);
19708                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
19709                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
19710                 ndr->depth--;
19711         }
19712         if (flags & NDR_OUT) {
19713                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
19714                 ndr->depth++;
19715                 ndr_print_ptr(ndr, "info", r->out.info);
19716                 ndr->depth++;
19717                 if (r->out.info) {
19718                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
19719                 }
19720                 ndr->depth--;
19721                 ndr_print_ptr(ndr, "needed", r->out.needed);
19722                 ndr->depth++;
19723                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19724                 ndr->depth--;
19725                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
19726                 ndr->depth++;
19727                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
19728                 ndr->depth--;
19729                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
19730                 ndr->depth++;
19731                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
19732                 ndr->depth--;
19733                 ndr_print_WERROR(ndr, "result", r->out.result);
19734                 ndr->depth--;
19735         }
19736         ndr->depth--;
19737 }
19738
19739 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
19740 {
19741         if (flags & NDR_IN) {
19742         }
19743         if (flags & NDR_OUT) {
19744                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19745         }
19746         return NDR_ERR_SUCCESS;
19747 }
19748
19749 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
19750 {
19751         if (flags & NDR_IN) {
19752         }
19753         if (flags & NDR_OUT) {
19754                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19755         }
19756         return NDR_ERR_SUCCESS;
19757 }
19758
19759 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
19760 {
19761         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
19762         ndr->depth++;
19763         if (flags & NDR_SET_VALUES) {
19764                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19765         }
19766         if (flags & NDR_IN) {
19767                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
19768                 ndr->depth++;
19769                 ndr->depth--;
19770         }
19771         if (flags & NDR_OUT) {
19772                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
19773                 ndr->depth++;
19774                 ndr_print_WERROR(ndr, "result", r->out.result);
19775                 ndr->depth--;
19776         }
19777         ndr->depth--;
19778 }
19779
19780 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
19781 {
19782         if (flags & NDR_IN) {
19783         }
19784         if (flags & NDR_OUT) {
19785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19786         }
19787         return NDR_ERR_SUCCESS;
19788 }
19789
19790 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
19791 {
19792         if (flags & NDR_IN) {
19793         }
19794         if (flags & NDR_OUT) {
19795                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19796         }
19797         return NDR_ERR_SUCCESS;
19798 }
19799
19800 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
19801 {
19802         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
19803         ndr->depth++;
19804         if (flags & NDR_SET_VALUES) {
19805                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19806         }
19807         if (flags & NDR_IN) {
19808                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
19809                 ndr->depth++;
19810                 ndr->depth--;
19811         }
19812         if (flags & NDR_OUT) {
19813                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
19814                 ndr->depth++;
19815                 ndr_print_WERROR(ndr, "result", r->out.result);
19816                 ndr->depth--;
19817         }
19818         ndr->depth--;
19819 }
19820
19821 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
19822 {
19823         if (flags & NDR_IN) {
19824                 if (r->in.handle == NULL) {
19825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19826                 }
19827                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19828         }
19829         if (flags & NDR_OUT) {
19830                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19831         }
19832         return NDR_ERR_SUCCESS;
19833 }
19834
19835 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
19836 {
19837         TALLOC_CTX *_mem_save_handle_0;
19838         if (flags & NDR_IN) {
19839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19840                         NDR_PULL_ALLOC(ndr, r->in.handle);
19841                 }
19842                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19843                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19844                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19846         }
19847         if (flags & NDR_OUT) {
19848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19849         }
19850         return NDR_ERR_SUCCESS;
19851 }
19852
19853 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
19854 {
19855         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
19856         ndr->depth++;
19857         if (flags & NDR_SET_VALUES) {
19858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19859         }
19860         if (flags & NDR_IN) {
19861                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
19862                 ndr->depth++;
19863                 ndr_print_ptr(ndr, "handle", r->in.handle);
19864                 ndr->depth++;
19865                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19866                 ndr->depth--;
19867                 ndr->depth--;
19868         }
19869         if (flags & NDR_OUT) {
19870                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
19871                 ndr->depth++;
19872                 ndr_print_WERROR(ndr, "result", r->out.result);
19873                 ndr->depth--;
19874         }
19875         ndr->depth--;
19876 }
19877
19878 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
19879 {
19880         if (flags & NDR_IN) {
19881         }
19882         if (flags & NDR_OUT) {
19883                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19884         }
19885         return NDR_ERR_SUCCESS;
19886 }
19887
19888 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
19889 {
19890         if (flags & NDR_IN) {
19891         }
19892         if (flags & NDR_OUT) {
19893                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19894         }
19895         return NDR_ERR_SUCCESS;
19896 }
19897
19898 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
19899 {
19900         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
19901         ndr->depth++;
19902         if (flags & NDR_SET_VALUES) {
19903                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19904         }
19905         if (flags & NDR_IN) {
19906                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
19907                 ndr->depth++;
19908                 ndr->depth--;
19909         }
19910         if (flags & NDR_OUT) {
19911                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
19912                 ndr->depth++;
19913                 ndr_print_WERROR(ndr, "result", r->out.result);
19914                 ndr->depth--;
19915         }
19916         ndr->depth--;
19917 }
19918
19919 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
19920 {
19921         if (flags & NDR_IN) {
19922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
19925                 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));
19926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
19927                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
19928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
19929                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19930                 if (r->in.buffer) {
19931                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
19932                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
19933                 }
19934         }
19935         if (flags & NDR_OUT) {
19936                 if (r->out.handle == NULL) {
19937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19938                 }
19939                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19940                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19941         }
19942         return NDR_ERR_SUCCESS;
19943 }
19944
19945 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
19946 {
19947         uint32_t _ptr_buffer;
19948         TALLOC_CTX *_mem_save_buffer_0;
19949         TALLOC_CTX *_mem_save_handle_0;
19950         if (flags & NDR_IN) {
19951                 ZERO_STRUCT(r->out);
19952
19953                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
19954                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
19955                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
19956                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
19957                 }
19958                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
19959                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
19960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
19961                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
19962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
19963                 if (r->in.bufsize > 512) {
19964                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
19965                 }
19966                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19967                 if (_ptr_buffer) {
19968                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19969                 } else {
19970                         r->in.buffer = NULL;
19971                 }
19972                 if (r->in.buffer) {
19973                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19974                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
19976                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
19977                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
19978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19979                 }
19980                 NDR_PULL_ALLOC(ndr, r->out.handle);
19981                 ZERO_STRUCTP(r->out.handle);
19982                 if (r->in.buffer) {
19983                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
19984                 }
19985         }
19986         if (flags & NDR_OUT) {
19987                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19988                         NDR_PULL_ALLOC(ndr, r->out.handle);
19989                 }
19990                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19991                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19992                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19993                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19994                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19995         }
19996         return NDR_ERR_SUCCESS;
19997 }
19998
19999 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
20000 {
20001         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
20002         ndr->depth++;
20003         if (flags & NDR_SET_VALUES) {
20004                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20005         }
20006         if (flags & NDR_IN) {
20007                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
20008                 ndr->depth++;
20009                 ndr_print_string(ndr, "server_name", r->in.server_name);
20010                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20011                 ndr_print_winreg_Type(ndr, "type", r->in.type);
20012                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20013                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20014                 ndr->depth++;
20015                 if (r->in.buffer) {
20016                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20017                 }
20018                 ndr->depth--;
20019                 ndr->depth--;
20020         }
20021         if (flags & NDR_OUT) {
20022                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
20023                 ndr->depth++;
20024                 ndr_print_ptr(ndr, "handle", r->out.handle);
20025                 ndr->depth++;
20026                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20027                 ndr->depth--;
20028                 ndr_print_WERROR(ndr, "result", r->out.result);
20029                 ndr->depth--;
20030         }
20031         ndr->depth--;
20032 }
20033
20034 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
20035 {
20036         if (flags & NDR_IN) {
20037                 if (r->in.handle == NULL) {
20038                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20039                 }
20040                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20041                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20044                 if (r->in.buffer) {
20045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
20046                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
20047                 }
20048         }
20049         if (flags & NDR_OUT) {
20050                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20051         }
20052         return NDR_ERR_SUCCESS;
20053 }
20054
20055 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
20056 {
20057         uint32_t _ptr_buffer;
20058         TALLOC_CTX *_mem_save_handle_0;
20059         TALLOC_CTX *_mem_save_buffer_0;
20060         if (flags & NDR_IN) {
20061                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20062                         NDR_PULL_ALLOC(ndr, r->in.handle);
20063                 }
20064                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20065                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20066                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20067                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20068                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
20070                 if (r->in.bufsize > 512) {
20071                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
20072                 }
20073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20074                 if (_ptr_buffer) {
20075                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20076                 } else {
20077                         r->in.buffer = NULL;
20078                 }
20079                 if (r->in.buffer) {
20080                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20081                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20082                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
20083                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
20084                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
20085                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20086                 }
20087                 if (r->in.buffer) {
20088                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
20089                 }
20090         }
20091         if (flags & NDR_OUT) {
20092                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20093         }
20094         return NDR_ERR_SUCCESS;
20095 }
20096
20097 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
20098 {
20099         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
20100         ndr->depth++;
20101         if (flags & NDR_SET_VALUES) {
20102                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20103         }
20104         if (flags & NDR_IN) {
20105                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
20106                 ndr->depth++;
20107                 ndr_print_ptr(ndr, "handle", r->in.handle);
20108                 ndr->depth++;
20109                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20110                 ndr->depth--;
20111                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20112                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
20113                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20114                 ndr->depth++;
20115                 if (r->in.buffer) {
20116                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
20117                 }
20118                 ndr->depth--;
20119                 ndr->depth--;
20120         }
20121         if (flags & NDR_OUT) {
20122                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
20123                 ndr->depth++;
20124                 ndr_print_WERROR(ndr, "result", r->out.result);
20125                 ndr->depth--;
20126         }
20127         ndr->depth--;
20128 }
20129
20130 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
20131 {
20132         if (flags & NDR_IN) {
20133                 if (r->in.handle == NULL) {
20134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20135                 }
20136                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20137         }
20138         if (flags & NDR_OUT) {
20139                 if (r->out.handle == NULL) {
20140                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20141                 }
20142                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20144         }
20145         return NDR_ERR_SUCCESS;
20146 }
20147
20148 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
20149 {
20150         TALLOC_CTX *_mem_save_handle_0;
20151         if (flags & NDR_IN) {
20152                 ZERO_STRUCT(r->out);
20153
20154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20155                         NDR_PULL_ALLOC(ndr, r->in.handle);
20156                 }
20157                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20158                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20159                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20161                 NDR_PULL_ALLOC(ndr, r->out.handle);
20162                 *r->out.handle = *r->in.handle;
20163         }
20164         if (flags & NDR_OUT) {
20165                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20166                         NDR_PULL_ALLOC(ndr, r->out.handle);
20167                 }
20168                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20169                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20170                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20172                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20173         }
20174         return NDR_ERR_SUCCESS;
20175 }
20176
20177 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
20178 {
20179         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
20180         ndr->depth++;
20181         if (flags & NDR_SET_VALUES) {
20182                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20183         }
20184         if (flags & NDR_IN) {
20185                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
20186                 ndr->depth++;
20187                 ndr_print_ptr(ndr, "handle", r->in.handle);
20188                 ndr->depth++;
20189                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20190                 ndr->depth--;
20191                 ndr->depth--;
20192         }
20193         if (flags & NDR_OUT) {
20194                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
20195                 ndr->depth++;
20196                 ndr_print_ptr(ndr, "handle", r->out.handle);
20197                 ndr->depth++;
20198                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20199                 ndr->depth--;
20200                 ndr_print_WERROR(ndr, "result", r->out.result);
20201                 ndr->depth--;
20202         }
20203         ndr->depth--;
20204 }
20205
20206 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
20207 {
20208         if (flags & NDR_IN) {
20209         }
20210         if (flags & NDR_OUT) {
20211                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20212         }
20213         return NDR_ERR_SUCCESS;
20214 }
20215
20216 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
20217 {
20218         if (flags & NDR_IN) {
20219         }
20220         if (flags & NDR_OUT) {
20221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20222         }
20223         return NDR_ERR_SUCCESS;
20224 }
20225
20226 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
20227 {
20228         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
20229         ndr->depth++;
20230         if (flags & NDR_SET_VALUES) {
20231                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20232         }
20233         if (flags & NDR_IN) {
20234                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
20235                 ndr->depth++;
20236                 ndr->depth--;
20237         }
20238         if (flags & NDR_OUT) {
20239                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
20240                 ndr->depth++;
20241                 ndr_print_WERROR(ndr, "result", r->out.result);
20242                 ndr->depth--;
20243         }
20244         ndr->depth--;
20245 }
20246
20247 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20248 {
20249         if (flags & NDR_IN) {
20250         }
20251         if (flags & NDR_OUT) {
20252                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20253         }
20254         return NDR_ERR_SUCCESS;
20255 }
20256
20257 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20258 {
20259         if (flags & NDR_IN) {
20260         }
20261         if (flags & NDR_OUT) {
20262                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20263         }
20264         return NDR_ERR_SUCCESS;
20265 }
20266
20267 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
20268 {
20269         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
20270         ndr->depth++;
20271         if (flags & NDR_SET_VALUES) {
20272                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20273         }
20274         if (flags & NDR_IN) {
20275                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
20276                 ndr->depth++;
20277                 ndr->depth--;
20278         }
20279         if (flags & NDR_OUT) {
20280                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
20281                 ndr->depth++;
20282                 ndr_print_WERROR(ndr, "result", r->out.result);
20283                 ndr->depth--;
20284         }
20285         ndr->depth--;
20286 }
20287
20288 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
20289 {
20290         if (flags & NDR_IN) {
20291         }
20292         if (flags & NDR_OUT) {
20293                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20294         }
20295         return NDR_ERR_SUCCESS;
20296 }
20297
20298 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
20299 {
20300         if (flags & NDR_IN) {
20301         }
20302         if (flags & NDR_OUT) {
20303                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20304         }
20305         return NDR_ERR_SUCCESS;
20306 }
20307
20308 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
20309 {
20310         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
20311         ndr->depth++;
20312         if (flags & NDR_SET_VALUES) {
20313                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20314         }
20315         if (flags & NDR_IN) {
20316                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
20317                 ndr->depth++;
20318                 ndr->depth--;
20319         }
20320         if (flags & NDR_OUT) {
20321                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
20322                 ndr->depth++;
20323                 ndr_print_WERROR(ndr, "result", r->out.result);
20324                 ndr->depth--;
20325         }
20326         ndr->depth--;
20327 }
20328
20329 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
20330 {
20331         if (flags & NDR_IN) {
20332         }
20333         if (flags & NDR_OUT) {
20334                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20335         }
20336         return NDR_ERR_SUCCESS;
20337 }
20338
20339 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
20340 {
20341         if (flags & NDR_IN) {
20342         }
20343         if (flags & NDR_OUT) {
20344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20345         }
20346         return NDR_ERR_SUCCESS;
20347 }
20348
20349 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
20350 {
20351         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
20352         ndr->depth++;
20353         if (flags & NDR_SET_VALUES) {
20354                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20355         }
20356         if (flags & NDR_IN) {
20357                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
20358                 ndr->depth++;
20359                 ndr->depth--;
20360         }
20361         if (flags & NDR_OUT) {
20362                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
20363                 ndr->depth++;
20364                 ndr_print_WERROR(ndr, "result", r->out.result);
20365                 ndr->depth--;
20366         }
20367         ndr->depth--;
20368 }
20369
20370 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20371 {
20372         if (flags & NDR_IN) {
20373                 if (r->in.handle == NULL) {
20374                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20375                 }
20376                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20377                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
20379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
20380                 if (r->in.local_machine) {
20381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
20384                         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));
20385                 }
20386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
20387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
20388                 if (r->in.notify_options) {
20389                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20390                 }
20391         }
20392         if (flags & NDR_OUT) {
20393                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20394         }
20395         return NDR_ERR_SUCCESS;
20396 }
20397
20398 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20399 {
20400         uint32_t _ptr_local_machine;
20401         uint32_t _ptr_notify_options;
20402         TALLOC_CTX *_mem_save_handle_0;
20403         TALLOC_CTX *_mem_save_local_machine_0;
20404         TALLOC_CTX *_mem_save_notify_options_0;
20405         if (flags & NDR_IN) {
20406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20407                         NDR_PULL_ALLOC(ndr, r->in.handle);
20408                 }
20409                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20410                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20411                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20413                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
20415                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
20416                 if (_ptr_local_machine) {
20417                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
20418                 } else {
20419                         r->in.local_machine = NULL;
20420                 }
20421                 if (r->in.local_machine) {
20422                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
20423                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
20424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
20425                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
20426                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
20427                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.local_machine), ndr_get_array_length(ndr, &r->in.local_machine));
20428                         }
20429                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
20430                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.local_machine, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t), CH_UTF16));
20431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
20432                 }
20433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
20434                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
20435                 if (_ptr_notify_options) {
20436                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
20437                 } else {
20438                         r->in.notify_options = NULL;
20439                 }
20440                 if (r->in.notify_options) {
20441                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20442                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
20443                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
20444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
20445                 }
20446         }
20447         if (flags & NDR_OUT) {
20448                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20449         }
20450         return NDR_ERR_SUCCESS;
20451 }
20452
20453 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
20454 {
20455         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20456         ndr->depth++;
20457         if (flags & NDR_SET_VALUES) {
20458                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20459         }
20460         if (flags & NDR_IN) {
20461                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20462                 ndr->depth++;
20463                 ndr_print_ptr(ndr, "handle", r->in.handle);
20464                 ndr->depth++;
20465                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20466                 ndr->depth--;
20467                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20468                 ndr_print_uint32(ndr, "options", r->in.options);
20469                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
20470                 ndr->depth++;
20471                 if (r->in.local_machine) {
20472                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
20473                 }
20474                 ndr->depth--;
20475                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
20476                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
20477                 ndr->depth++;
20478                 if (r->in.notify_options) {
20479                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
20480                 }
20481                 ndr->depth--;
20482                 ndr->depth--;
20483         }
20484         if (flags & NDR_OUT) {
20485                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
20486                 ndr->depth++;
20487                 ndr_print_WERROR(ndr, "result", r->out.result);
20488                 ndr->depth--;
20489         }
20490         ndr->depth--;
20491 }
20492
20493 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
20494 {
20495         if (flags & NDR_IN) {
20496                 if (r->in.handle == NULL) {
20497                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20498                 }
20499                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
20501                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
20502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
20503                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
20504                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20505         }
20506         if (flags & NDR_OUT) {
20507                 if (r->out.reply_result == NULL) {
20508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20509                 }
20510                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
20511                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20512         }
20513         return NDR_ERR_SUCCESS;
20514 }
20515
20516 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
20517 {
20518         TALLOC_CTX *_mem_save_handle_0;
20519         TALLOC_CTX *_mem_save_reply_result_0;
20520         if (flags & NDR_IN) {
20521                 ZERO_STRUCT(r->out);
20522
20523                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20524                         NDR_PULL_ALLOC(ndr, r->in.handle);
20525                 }
20526                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20527                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20528                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20529                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
20531                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
20532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
20533                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
20534                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20535                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
20536                 ZERO_STRUCTP(r->out.reply_result);
20537         }
20538         if (flags & NDR_OUT) {
20539                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20540                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
20541                 }
20542                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
20543                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
20544                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
20545                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
20546                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20547         }
20548         return NDR_ERR_SUCCESS;
20549 }
20550
20551 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
20552 {
20553         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
20554         ndr->depth++;
20555         if (flags & NDR_SET_VALUES) {
20556                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20557         }
20558         if (flags & NDR_IN) {
20559                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
20560                 ndr->depth++;
20561                 ndr_print_ptr(ndr, "handle", r->in.handle);
20562                 ndr->depth++;
20563                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20564                 ndr->depth--;
20565                 ndr_print_uint32(ndr, "color", r->in.color);
20566                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
20567                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
20568                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
20569                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
20570                 ndr->depth--;
20571         }
20572         if (flags & NDR_OUT) {
20573                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
20574                 ndr->depth++;
20575                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
20576                 ndr->depth++;
20577                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
20578                 ndr->depth--;
20579                 ndr_print_WERROR(ndr, "result", r->out.result);
20580                 ndr->depth--;
20581         }
20582         ndr->depth--;
20583 }
20584
20585 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
20586 {
20587         if (flags & NDR_IN) {
20588                 if (r->in.handle == NULL) {
20589                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20590                 }
20591                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
20593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
20594                 if (r->in.options) {
20595                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
20596                 }
20597         }
20598         if (flags & NDR_OUT) {
20599                 if (r->out.info == NULL) {
20600                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20601                 }
20602                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
20603                 if (*r->out.info) {
20604                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
20605                 }
20606                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20607         }
20608         return NDR_ERR_SUCCESS;
20609 }
20610
20611 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
20612 {
20613         uint32_t _ptr_options;
20614         uint32_t _ptr_info;
20615         TALLOC_CTX *_mem_save_handle_0;
20616         TALLOC_CTX *_mem_save_options_0;
20617         TALLOC_CTX *_mem_save_info_0;
20618         TALLOC_CTX *_mem_save_info_1;
20619         if (flags & NDR_IN) {
20620                 ZERO_STRUCT(r->out);
20621
20622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20623                         NDR_PULL_ALLOC(ndr, r->in.handle);
20624                 }
20625                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20626                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20627                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
20630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
20631                 if (_ptr_options) {
20632                         NDR_PULL_ALLOC(ndr, r->in.options);
20633                 } else {
20634                         r->in.options = NULL;
20635                 }
20636                 if (r->in.options) {
20637                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
20638                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
20639                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
20640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
20641                 }
20642                 NDR_PULL_ALLOC(ndr, r->out.info);
20643                 ZERO_STRUCTP(r->out.info);
20644         }
20645         if (flags & NDR_OUT) {
20646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20647                         NDR_PULL_ALLOC(ndr, r->out.info);
20648                 }
20649                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20650                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
20651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20652                 if (_ptr_info) {
20653                         NDR_PULL_ALLOC(ndr, *r->out.info);
20654                 } else {
20655                         *r->out.info = NULL;
20656                 }
20657                 if (*r->out.info) {
20658                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
20659                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
20660                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
20661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
20662                 }
20663                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
20664                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20665         }
20666         return NDR_ERR_SUCCESS;
20667 }
20668
20669 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
20670 {
20671         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
20672         ndr->depth++;
20673         if (flags & NDR_SET_VALUES) {
20674                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20675         }
20676         if (flags & NDR_IN) {
20677                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
20678                 ndr->depth++;
20679                 ndr_print_ptr(ndr, "handle", r->in.handle);
20680                 ndr->depth++;
20681                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20682                 ndr->depth--;
20683                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
20684                 ndr_print_ptr(ndr, "options", r->in.options);
20685                 ndr->depth++;
20686                 if (r->in.options) {
20687                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
20688                 }
20689                 ndr->depth--;
20690                 ndr->depth--;
20691         }
20692         if (flags & NDR_OUT) {
20693                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
20694                 ndr->depth++;
20695                 ndr_print_ptr(ndr, "info", r->out.info);
20696                 ndr->depth++;
20697                 ndr_print_ptr(ndr, "info", *r->out.info);
20698                 ndr->depth++;
20699                 if (*r->out.info) {
20700                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
20701                 }
20702                 ndr->depth--;
20703                 ndr->depth--;
20704                 ndr_print_WERROR(ndr, "result", r->out.result);
20705                 ndr->depth--;
20706         }
20707         ndr->depth--;
20708 }
20709
20710 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
20711 {
20712         if (flags & NDR_IN) {
20713         }
20714         if (flags & NDR_OUT) {
20715                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20716         }
20717         return NDR_ERR_SUCCESS;
20718 }
20719
20720 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
20721 {
20722         if (flags & NDR_IN) {
20723         }
20724         if (flags & NDR_OUT) {
20725                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20726         }
20727         return NDR_ERR_SUCCESS;
20728 }
20729
20730 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
20731 {
20732         ndr_print_struct(ndr, name, "spoolss_44");
20733         ndr->depth++;
20734         if (flags & NDR_SET_VALUES) {
20735                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20736         }
20737         if (flags & NDR_IN) {
20738                 ndr_print_struct(ndr, "in", "spoolss_44");
20739                 ndr->depth++;
20740                 ndr->depth--;
20741         }
20742         if (flags & NDR_OUT) {
20743                 ndr_print_struct(ndr, "out", "spoolss_44");
20744                 ndr->depth++;
20745                 ndr_print_WERROR(ndr, "result", r->out.result);
20746                 ndr->depth--;
20747         }
20748         ndr->depth--;
20749 }
20750
20751 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
20752 {
20753         if (flags & NDR_IN) {
20754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20755                 if (r->in.printername) {
20756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20759                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20760                 }
20761                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20762                 if (r->in.datatype) {
20763                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20766                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20767                 }
20768                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20769                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20771                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
20772                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
20773         }
20774         if (flags & NDR_OUT) {
20775                 if (r->out.handle == NULL) {
20776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20777                 }
20778                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20779                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20780         }
20781         return NDR_ERR_SUCCESS;
20782 }
20783
20784 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
20785 {
20786         uint32_t _ptr_printername;
20787         uint32_t _ptr_datatype;
20788         TALLOC_CTX *_mem_save_printername_0;
20789         TALLOC_CTX *_mem_save_datatype_0;
20790         TALLOC_CTX *_mem_save_handle_0;
20791         if (flags & NDR_IN) {
20792                 ZERO_STRUCT(r->out);
20793
20794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20795                 if (_ptr_printername) {
20796                         NDR_PULL_ALLOC(ndr, r->in.printername);
20797                 } else {
20798                         r->in.printername = NULL;
20799                 }
20800                 if (r->in.printername) {
20801                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20802                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20805                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20806                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.printername), ndr_get_array_length(ndr, &r->in.printername));
20807                         }
20808                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20811                 }
20812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20813                 if (_ptr_datatype) {
20814                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20815                 } else {
20816                         r->in.datatype = NULL;
20817                 }
20818                 if (r->in.datatype) {
20819                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20820                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20821                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20822                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20823                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20824                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
20825                         }
20826                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20827                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20829                 }
20830                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20831                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20833                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
20834                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
20835                 NDR_PULL_ALLOC(ndr, r->out.handle);
20836                 ZERO_STRUCTP(r->out.handle);
20837         }
20838         if (flags & NDR_OUT) {
20839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20840                         NDR_PULL_ALLOC(ndr, r->out.handle);
20841                 }
20842                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20843                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20844                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20846                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20847         }
20848         return NDR_ERR_SUCCESS;
20849 }
20850
20851 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
20852 {
20853         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
20854         ndr->depth++;
20855         if (flags & NDR_SET_VALUES) {
20856                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20857         }
20858         if (flags & NDR_IN) {
20859                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
20860                 ndr->depth++;
20861                 ndr_print_ptr(ndr, "printername", r->in.printername);
20862                 ndr->depth++;
20863                 if (r->in.printername) {
20864                         ndr_print_string(ndr, "printername", r->in.printername);
20865                 }
20866                 ndr->depth--;
20867                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20868                 ndr->depth++;
20869                 if (r->in.datatype) {
20870                         ndr_print_string(ndr, "datatype", r->in.datatype);
20871                 }
20872                 ndr->depth--;
20873                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20874                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20875                 ndr_print_uint32(ndr, "level", r->in.level);
20876                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
20877                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
20878                 ndr->depth--;
20879         }
20880         if (flags & NDR_OUT) {
20881                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
20882                 ndr->depth++;
20883                 ndr_print_ptr(ndr, "handle", r->out.handle);
20884                 ndr->depth++;
20885                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20886                 ndr->depth--;
20887                 ndr_print_WERROR(ndr, "result", r->out.result);
20888                 ndr->depth--;
20889         }
20890         ndr->depth--;
20891 }
20892
20893 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
20894 {
20895         if (flags & NDR_IN) {
20896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20897                 if (r->in.server) {
20898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20900                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20901                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20902                 }
20903                 if (r->in.info_ctr == NULL) {
20904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20905                 }
20906                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20907                 if (r->in.devmode_ctr == NULL) {
20908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20909                 }
20910                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20911                 if (r->in.secdesc_ctr == NULL) {
20912                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20913                 }
20914                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20915                 if (r->in.userlevel_ctr == NULL) {
20916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20917                 }
20918                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
20919         }
20920         if (flags & NDR_OUT) {
20921                 if (r->out.handle == NULL) {
20922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20923                 }
20924                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20926         }
20927         return NDR_ERR_SUCCESS;
20928 }
20929
20930 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
20931 {
20932         uint32_t _ptr_server;
20933         TALLOC_CTX *_mem_save_server_0;
20934         TALLOC_CTX *_mem_save_info_ctr_0;
20935         TALLOC_CTX *_mem_save_devmode_ctr_0;
20936         TALLOC_CTX *_mem_save_secdesc_ctr_0;
20937         TALLOC_CTX *_mem_save_userlevel_ctr_0;
20938         TALLOC_CTX *_mem_save_handle_0;
20939         if (flags & NDR_IN) {
20940                 ZERO_STRUCT(r->out);
20941
20942                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20943                 if (_ptr_server) {
20944                         NDR_PULL_ALLOC(ndr, r->in.server);
20945                 } else {
20946                         r->in.server = NULL;
20947                 }
20948                 if (r->in.server) {
20949                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20950                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20951                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20952                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20953                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20954                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
20955                         }
20956                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20957                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20959                 }
20960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20961                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20962                 }
20963                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20964                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20965                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20967                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20968                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20969                 }
20970                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20971                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20972                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20973                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20974                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20975                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20976                 }
20977                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20978                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20979                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20980                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20982                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
20983                 }
20984                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20985                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
20986                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
20987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20988                 NDR_PULL_ALLOC(ndr, r->out.handle);
20989                 ZERO_STRUCTP(r->out.handle);
20990         }
20991         if (flags & NDR_OUT) {
20992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20993                         NDR_PULL_ALLOC(ndr, r->out.handle);
20994                 }
20995                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20996                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20997                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20998                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20999                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21000         }
21001         return NDR_ERR_SUCCESS;
21002 }
21003
21004 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
21005 {
21006         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
21007         ndr->depth++;
21008         if (flags & NDR_SET_VALUES) {
21009                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21010         }
21011         if (flags & NDR_IN) {
21012                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
21013                 ndr->depth++;
21014                 ndr_print_ptr(ndr, "server", r->in.server);
21015                 ndr->depth++;
21016                 if (r->in.server) {
21017                         ndr_print_string(ndr, "server", r->in.server);
21018                 }
21019                 ndr->depth--;
21020                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21021                 ndr->depth++;
21022                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21023                 ndr->depth--;
21024                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21025                 ndr->depth++;
21026                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21027                 ndr->depth--;
21028                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21029                 ndr->depth++;
21030                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21031                 ndr->depth--;
21032                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21033                 ndr->depth++;
21034                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
21035                 ndr->depth--;
21036                 ndr->depth--;
21037         }
21038         if (flags & NDR_OUT) {
21039                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
21040                 ndr->depth++;
21041                 ndr_print_ptr(ndr, "handle", r->out.handle);
21042                 ndr->depth++;
21043                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21044                 ndr->depth--;
21045                 ndr_print_WERROR(ndr, "result", r->out.result);
21046                 ndr->depth--;
21047         }
21048         ndr->depth--;
21049 }
21050
21051 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
21052 {
21053         if (flags & NDR_IN) {
21054         }
21055         if (flags & NDR_OUT) {
21056                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21057         }
21058         return NDR_ERR_SUCCESS;
21059 }
21060
21061 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
21062 {
21063         if (flags & NDR_IN) {
21064         }
21065         if (flags & NDR_OUT) {
21066                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21067         }
21068         return NDR_ERR_SUCCESS;
21069 }
21070
21071 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
21072 {
21073         ndr_print_struct(ndr, name, "spoolss_47");
21074         ndr->depth++;
21075         if (flags & NDR_SET_VALUES) {
21076                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21077         }
21078         if (flags & NDR_IN) {
21079                 ndr_print_struct(ndr, "in", "spoolss_47");
21080                 ndr->depth++;
21081                 ndr->depth--;
21082         }
21083         if (flags & NDR_OUT) {
21084                 ndr_print_struct(ndr, "out", "spoolss_47");
21085                 ndr->depth++;
21086                 ndr_print_WERROR(ndr, "result", r->out.result);
21087                 ndr->depth--;
21088         }
21089         ndr->depth--;
21090 }
21091
21092 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
21093 {
21094         if (flags & NDR_IN) {
21095                 if (r->in.handle == NULL) {
21096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21097                 }
21098                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
21100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
21101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
21102         }
21103         if (flags & NDR_OUT) {
21104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
21105                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
21106                 if (r->out.value_needed == NULL) {
21107                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21108                 }
21109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
21110                 if (r->out.printerdata_type == NULL) {
21111                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21112                 }
21113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
21114                 if (r->out.buffer == NULL) {
21115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21116                 }
21117                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
21118                 if (r->out.data_needed == NULL) {
21119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21120                 }
21121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
21122                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21123         }
21124         return NDR_ERR_SUCCESS;
21125 }
21126
21127 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
21128 {
21129         TALLOC_CTX *_mem_save_handle_0;
21130         TALLOC_CTX *_mem_save_value_needed_0;
21131         TALLOC_CTX *_mem_save_printerdata_type_0;
21132         TALLOC_CTX *_mem_save_buffer_0;
21133         TALLOC_CTX *_mem_save_data_needed_0;
21134         if (flags & NDR_IN) {
21135                 ZERO_STRUCT(r->out);
21136
21137                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21138                         NDR_PULL_ALLOC(ndr, r->in.handle);
21139                 }
21140                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21141                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21142                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
21145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
21146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
21147                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
21148                 ZERO_STRUCTP(r->out.value_needed);
21149                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21150                 ZERO_STRUCTP(r->out.printerdata_type);
21151                 NDR_PULL_ALLOC(ndr, r->out.buffer);
21152                 ZERO_STRUCTP(r->out.buffer);
21153                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
21154                 ZERO_STRUCTP(r->out.data_needed);
21155         }
21156         if (flags & NDR_OUT) {
21157                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
21158                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.value_name, ndr_get_array_size(ndr, &r->out.value_name), sizeof(uint16_t), CH_UTF16));
21159                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21160                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
21161                 }
21162                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21163                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
21164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
21165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
21166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21167                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
21168                 }
21169                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21170                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
21171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
21172                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
21173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21174                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21175                 }
21176                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21177                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
21178                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
21179                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
21180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21181                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
21182                 }
21183                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21184                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
21185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
21186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
21187                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21188                 if (r->out.value_name) {
21189                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
21190                 }
21191         }
21192         return NDR_ERR_SUCCESS;
21193 }
21194
21195 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
21196 {
21197         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
21198         ndr->depth++;
21199         if (flags & NDR_SET_VALUES) {
21200                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21201         }
21202         if (flags & NDR_IN) {
21203                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
21204                 ndr->depth++;
21205                 ndr_print_ptr(ndr, "handle", r->in.handle);
21206                 ndr->depth++;
21207                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21208                 ndr->depth--;
21209                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
21210                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
21211                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
21212                 ndr->depth--;
21213         }
21214         if (flags & NDR_OUT) {
21215                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
21216                 ndr->depth++;
21217                 ndr_print_string(ndr, "value_name", r->out.value_name);
21218                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
21219                 ndr->depth++;
21220                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
21221                 ndr->depth--;
21222                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
21223                 ndr->depth++;
21224                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
21225                 ndr->depth--;
21226                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21227                 ndr->depth++;
21228                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
21229                 ndr->depth--;
21230                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
21231                 ndr->depth++;
21232                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
21233                 ndr->depth--;
21234                 ndr_print_WERROR(ndr, "result", r->out.result);
21235                 ndr->depth--;
21236         }
21237         ndr->depth--;
21238 }
21239
21240 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
21241 {
21242         if (flags & NDR_IN) {
21243                 if (r->in.handle == NULL) {
21244                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21245                 }
21246                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21250                 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));
21251         }
21252         if (flags & NDR_OUT) {
21253                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21254         }
21255         return NDR_ERR_SUCCESS;
21256 }
21257
21258 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
21259 {
21260         TALLOC_CTX *_mem_save_handle_0;
21261         if (flags & NDR_IN) {
21262                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21263                         NDR_PULL_ALLOC(ndr, r->in.handle);
21264                 }
21265                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21266                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21267                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21268                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21269                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21270                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21271                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21272                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
21273                 }
21274                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21275                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
21276         }
21277         if (flags & NDR_OUT) {
21278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21279         }
21280         return NDR_ERR_SUCCESS;
21281 }
21282
21283 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
21284 {
21285         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
21286         ndr->depth++;
21287         if (flags & NDR_SET_VALUES) {
21288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21289         }
21290         if (flags & NDR_IN) {
21291                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
21292                 ndr->depth++;
21293                 ndr_print_ptr(ndr, "handle", r->in.handle);
21294                 ndr->depth++;
21295                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21296                 ndr->depth--;
21297                 ndr_print_string(ndr, "value_name", r->in.value_name);
21298                 ndr->depth--;
21299         }
21300         if (flags & NDR_OUT) {
21301                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
21302                 ndr->depth++;
21303                 ndr_print_WERROR(ndr, "result", r->out.result);
21304                 ndr->depth--;
21305         }
21306         ndr->depth--;
21307 }
21308
21309 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
21310 {
21311         if (flags & NDR_IN) {
21312         }
21313         if (flags & NDR_OUT) {
21314                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21315         }
21316         return NDR_ERR_SUCCESS;
21317 }
21318
21319 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
21320 {
21321         if (flags & NDR_IN) {
21322         }
21323         if (flags & NDR_OUT) {
21324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21325         }
21326         return NDR_ERR_SUCCESS;
21327 }
21328
21329 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
21330 {
21331         ndr_print_struct(ndr, name, "spoolss_4a");
21332         ndr->depth++;
21333         if (flags & NDR_SET_VALUES) {
21334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21335         }
21336         if (flags & NDR_IN) {
21337                 ndr_print_struct(ndr, "in", "spoolss_4a");
21338                 ndr->depth++;
21339                 ndr->depth--;
21340         }
21341         if (flags & NDR_OUT) {
21342                 ndr_print_struct(ndr, "out", "spoolss_4a");
21343                 ndr->depth++;
21344                 ndr_print_WERROR(ndr, "result", r->out.result);
21345                 ndr->depth--;
21346         }
21347         ndr->depth--;
21348 }
21349
21350 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
21351 {
21352         if (flags & NDR_IN) {
21353         }
21354         if (flags & NDR_OUT) {
21355                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21356         }
21357         return NDR_ERR_SUCCESS;
21358 }
21359
21360 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
21361 {
21362         if (flags & NDR_IN) {
21363         }
21364         if (flags & NDR_OUT) {
21365                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21366         }
21367         return NDR_ERR_SUCCESS;
21368 }
21369
21370 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
21371 {
21372         ndr_print_struct(ndr, name, "spoolss_4b");
21373         ndr->depth++;
21374         if (flags & NDR_SET_VALUES) {
21375                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21376         }
21377         if (flags & NDR_IN) {
21378                 ndr_print_struct(ndr, "in", "spoolss_4b");
21379                 ndr->depth++;
21380                 ndr->depth--;
21381         }
21382         if (flags & NDR_OUT) {
21383                 ndr_print_struct(ndr, "out", "spoolss_4b");
21384                 ndr->depth++;
21385                 ndr_print_WERROR(ndr, "result", r->out.result);
21386                 ndr->depth--;
21387         }
21388         ndr->depth--;
21389 }
21390
21391 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
21392 {
21393         if (flags & NDR_IN) {
21394         }
21395         if (flags & NDR_OUT) {
21396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21397         }
21398         return NDR_ERR_SUCCESS;
21399 }
21400
21401 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
21402 {
21403         if (flags & NDR_IN) {
21404         }
21405         if (flags & NDR_OUT) {
21406                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21407         }
21408         return NDR_ERR_SUCCESS;
21409 }
21410
21411 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
21412 {
21413         ndr_print_struct(ndr, name, "spoolss_4c");
21414         ndr->depth++;
21415         if (flags & NDR_SET_VALUES) {
21416                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21417         }
21418         if (flags & NDR_IN) {
21419                 ndr_print_struct(ndr, "in", "spoolss_4c");
21420                 ndr->depth++;
21421                 ndr->depth--;
21422         }
21423         if (flags & NDR_OUT) {
21424                 ndr_print_struct(ndr, "out", "spoolss_4c");
21425                 ndr->depth++;
21426                 ndr_print_WERROR(ndr, "result", r->out.result);
21427                 ndr->depth--;
21428         }
21429         ndr->depth--;
21430 }
21431
21432 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
21433 {
21434         if (flags & NDR_IN) {
21435                 if (r->in.handle == NULL) {
21436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21437                 }
21438                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21442                 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));
21443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21446                 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));
21447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
21448                 if (r->in.buffer == NULL) {
21449                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21450                 }
21451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21452                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21454         }
21455         if (flags & NDR_OUT) {
21456                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21457         }
21458         return NDR_ERR_SUCCESS;
21459 }
21460
21461 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
21462 {
21463         TALLOC_CTX *_mem_save_handle_0;
21464         if (flags & NDR_IN) {
21465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21466                         NDR_PULL_ALLOC(ndr, r->in.handle);
21467                 }
21468                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21469                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21470                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21472                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21473                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21474                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21475                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
21476                 }
21477                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21478                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
21479                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21480                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21481                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21482                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
21483                 }
21484                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21485                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
21486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
21487                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21488                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21489                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21490                 }
21491                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21493                 if (r->in.buffer) {
21494                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21495                 }
21496         }
21497         if (flags & NDR_OUT) {
21498                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21499         }
21500         return NDR_ERR_SUCCESS;
21501 }
21502
21503 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
21504 {
21505         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
21506         ndr->depth++;
21507         if (flags & NDR_SET_VALUES) {
21508                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21509         }
21510         if (flags & NDR_IN) {
21511                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
21512                 ndr->depth++;
21513                 ndr_print_ptr(ndr, "handle", r->in.handle);
21514                 ndr->depth++;
21515                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21516                 ndr->depth--;
21517                 ndr_print_string(ndr, "key_name", r->in.key_name);
21518                 ndr_print_string(ndr, "value_name", r->in.value_name);
21519                 ndr_print_uint32(ndr, "type", r->in.type);
21520                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21521                 ndr->depth++;
21522                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21523                 ndr->depth--;
21524                 ndr_print_uint32(ndr, "offered", r->in.offered);
21525                 ndr->depth--;
21526         }
21527         if (flags & NDR_OUT) {
21528                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
21529                 ndr->depth++;
21530                 ndr_print_WERROR(ndr, "result", r->out.result);
21531                 ndr->depth--;
21532         }
21533         ndr->depth--;
21534 }
21535
21536 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
21537 {
21538         if (flags & NDR_IN) {
21539                 if (r->in.handle == NULL) {
21540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21541                 }
21542                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21546                 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));
21547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21550                 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));
21551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21552         }
21553         if (flags & NDR_OUT) {
21554                 if (r->out.type == NULL) {
21555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21556                 }
21557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
21558                 if (r->out.buffer == NULL) {
21559                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21560                 }
21561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21562                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21563                 if (r->out.needed == NULL) {
21564                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21565                 }
21566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21567                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21568         }
21569         return NDR_ERR_SUCCESS;
21570 }
21571
21572 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
21573 {
21574         TALLOC_CTX *_mem_save_handle_0;
21575         TALLOC_CTX *_mem_save_type_0;
21576         TALLOC_CTX *_mem_save_needed_0;
21577         if (flags & NDR_IN) {
21578                 ZERO_STRUCT(r->out);
21579
21580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21581                         NDR_PULL_ALLOC(ndr, r->in.handle);
21582                 }
21583                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21584                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21585                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21587                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21588                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21589                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21590                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
21591                 }
21592                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21593                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
21594                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21595                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21596                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21597                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
21598                 }
21599                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21600                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
21601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21602                 NDR_PULL_ALLOC(ndr, r->out.type);
21603                 ZERO_STRUCTP(r->out.type);
21604                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
21605                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
21606                 NDR_PULL_ALLOC(ndr, r->out.needed);
21607                 ZERO_STRUCTP(r->out.needed);
21608         }
21609         if (flags & NDR_OUT) {
21610                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21611                         NDR_PULL_ALLOC(ndr, r->out.type);
21612                 }
21613                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21614                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
21616                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21617                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21618                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21619                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21620                 }
21621                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21623                         NDR_PULL_ALLOC(ndr, r->out.needed);
21624                 }
21625                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21626                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21629                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21630                 if (r->out.buffer) {
21631                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21632                 }
21633         }
21634         return NDR_ERR_SUCCESS;
21635 }
21636
21637 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
21638 {
21639         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
21640         ndr->depth++;
21641         if (flags & NDR_SET_VALUES) {
21642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21643         }
21644         if (flags & NDR_IN) {
21645                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
21646                 ndr->depth++;
21647                 ndr_print_ptr(ndr, "handle", r->in.handle);
21648                 ndr->depth++;
21649                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21650                 ndr->depth--;
21651                 ndr_print_string(ndr, "key_name", r->in.key_name);
21652                 ndr_print_string(ndr, "value_name", r->in.value_name);
21653                 ndr_print_uint32(ndr, "offered", r->in.offered);
21654                 ndr->depth--;
21655         }
21656         if (flags & NDR_OUT) {
21657                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
21658                 ndr->depth++;
21659                 ndr_print_ptr(ndr, "type", r->out.type);
21660                 ndr->depth++;
21661                 ndr_print_uint32(ndr, "type", *r->out.type);
21662                 ndr->depth--;
21663                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21664                 ndr->depth++;
21665                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21666                 ndr->depth--;
21667                 ndr_print_ptr(ndr, "needed", r->out.needed);
21668                 ndr->depth++;
21669                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21670                 ndr->depth--;
21671                 ndr_print_WERROR(ndr, "result", r->out.result);
21672                 ndr->depth--;
21673         }
21674         ndr->depth--;
21675 }
21676
21677 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
21678 {
21679         if (flags & NDR_IN) {
21680                 if (r->in.handle == NULL) {
21681                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21682                 }
21683                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21687                 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));
21688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21689         }
21690         if (flags & NDR_OUT) {
21691                 if (r->out.buffer == NULL) {
21692                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21693                 }
21694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21695                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21696                 if (r->out.needed == NULL) {
21697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21698                 }
21699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21700                 if (r->out.count == NULL) {
21701                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21702                 }
21703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21704                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21705         }
21706         return NDR_ERR_SUCCESS;
21707 }
21708
21709 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
21710 {
21711         TALLOC_CTX *_mem_save_handle_0;
21712         TALLOC_CTX *_mem_save_needed_0;
21713         TALLOC_CTX *_mem_save_count_0;
21714         if (flags & NDR_IN) {
21715                 ZERO_STRUCT(r->out);
21716
21717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21718                         NDR_PULL_ALLOC(ndr, r->in.handle);
21719                 }
21720                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21721                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21722                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21724                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21725                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21726                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21727                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
21728                 }
21729                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21730                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
21731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21732                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
21733                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
21734                 NDR_PULL_ALLOC(ndr, r->out.needed);
21735                 ZERO_STRUCTP(r->out.needed);
21736                 NDR_PULL_ALLOC(ndr, r->out.count);
21737                 ZERO_STRUCTP(r->out.count);
21738         }
21739         if (flags & NDR_OUT) {
21740                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21742                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21743                 }
21744                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21745                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21746                         NDR_PULL_ALLOC(ndr, r->out.needed);
21747                 }
21748                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21749                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21753                         NDR_PULL_ALLOC(ndr, r->out.count);
21754                 }
21755                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21756                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21759                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21760                 if (r->out.buffer) {
21761                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21762                 }
21763         }
21764         return NDR_ERR_SUCCESS;
21765 }
21766
21767 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
21768 {
21769         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
21770         ndr->depth++;
21771         if (flags & NDR_SET_VALUES) {
21772                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21773         }
21774         if (flags & NDR_IN) {
21775                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
21776                 ndr->depth++;
21777                 ndr_print_ptr(ndr, "handle", r->in.handle);
21778                 ndr->depth++;
21779                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21780                 ndr->depth--;
21781                 ndr_print_string(ndr, "key_name", r->in.key_name);
21782                 ndr_print_uint32(ndr, "offered", r->in.offered);
21783                 ndr->depth--;
21784         }
21785         if (flags & NDR_OUT) {
21786                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
21787                 ndr->depth++;
21788                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21789                 ndr->depth++;
21790                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21791                 ndr->depth--;
21792                 ndr_print_ptr(ndr, "needed", r->out.needed);
21793                 ndr->depth++;
21794                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21795                 ndr->depth--;
21796                 ndr_print_ptr(ndr, "count", r->out.count);
21797                 ndr->depth++;
21798                 ndr_print_uint32(ndr, "count", *r->out.count);
21799                 ndr->depth--;
21800                 ndr_print_WERROR(ndr, "result", r->out.result);
21801                 ndr->depth--;
21802         }
21803         ndr->depth--;
21804 }
21805
21806 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
21807 {
21808         uint32_t cntr_key_buffer_1;
21809         if (flags & NDR_IN) {
21810                 if (r->in.handle == NULL) {
21811                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21812                 }
21813                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21817                 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));
21818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
21819         }
21820         if (flags & NDR_OUT) {
21821                 if (r->out.key_buffer == NULL) {
21822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21823                 }
21824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
21825                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
21826                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
21827                 }
21828                 if (r->out.needed == NULL) {
21829                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21830                 }
21831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21833         }
21834         return NDR_ERR_SUCCESS;
21835 }
21836
21837 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
21838 {
21839         uint32_t cntr_key_buffer_1;
21840         TALLOC_CTX *_mem_save_handle_0;
21841         TALLOC_CTX *_mem_save_key_buffer_1;
21842         TALLOC_CTX *_mem_save_needed_0;
21843         if (flags & NDR_IN) {
21844                 ZERO_STRUCT(r->out);
21845
21846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21847                         NDR_PULL_ALLOC(ndr, r->in.handle);
21848                 }
21849                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21850                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21851                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21852                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21853                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21854                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21855                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21856                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
21857                 }
21858                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21859                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
21860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
21861                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
21862                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
21863                 NDR_PULL_ALLOC(ndr, r->out.needed);
21864                 ZERO_STRUCTP(r->out.needed);
21865         }
21866         if (flags & NDR_OUT) {
21867                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
21868                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21869                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
21870                 }
21871                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
21872                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
21873                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
21874                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
21875                 }
21876                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
21877                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21878                         NDR_PULL_ALLOC(ndr, r->out.needed);
21879                 }
21880                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21881                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21883                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21884                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21885                 if (r->out.key_buffer) {
21886                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
21887                 }
21888         }
21889         return NDR_ERR_SUCCESS;
21890 }
21891
21892 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
21893 {
21894         uint32_t cntr_key_buffer_1;
21895         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
21896         ndr->depth++;
21897         if (flags & NDR_SET_VALUES) {
21898                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21899         }
21900         if (flags & NDR_IN) {
21901                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
21902                 ndr->depth++;
21903                 ndr_print_ptr(ndr, "handle", r->in.handle);
21904                 ndr->depth++;
21905                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21906                 ndr->depth--;
21907                 ndr_print_string(ndr, "key_name", r->in.key_name);
21908                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
21909                 ndr->depth--;
21910         }
21911         if (flags & NDR_OUT) {
21912                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
21913                 ndr->depth++;
21914                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
21915                 ndr->depth++;
21916                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
21917                 ndr->depth++;
21918                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
21919                         char *idx_1=NULL;
21920                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
21921                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
21922                                 free(idx_1);
21923                         }
21924                 }
21925                 ndr->depth--;
21926                 ndr->depth--;
21927                 ndr_print_ptr(ndr, "needed", r->out.needed);
21928                 ndr->depth++;
21929                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21930                 ndr->depth--;
21931                 ndr_print_WERROR(ndr, "result", r->out.result);
21932                 ndr->depth--;
21933         }
21934         ndr->depth--;
21935 }
21936
21937 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
21938 {
21939         if (flags & NDR_IN) {
21940                 if (r->in.handle == NULL) {
21941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21942                 }
21943                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
21947                 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));
21948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21951                 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));
21952         }
21953         if (flags & NDR_OUT) {
21954                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21955         }
21956         return NDR_ERR_SUCCESS;
21957 }
21958
21959 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
21960 {
21961         TALLOC_CTX *_mem_save_handle_0;
21962         if (flags & NDR_IN) {
21963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21964                         NDR_PULL_ALLOC(ndr, r->in.handle);
21965                 }
21966                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21967                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21968                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21970                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
21971                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
21972                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
21973                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
21974                 }
21975                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
21976                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
21977                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21978                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21979                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21980                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
21981                 }
21982                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21983                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
21984         }
21985         if (flags & NDR_OUT) {
21986                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21987         }
21988         return NDR_ERR_SUCCESS;
21989 }
21990
21991 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
21992 {
21993         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
21994         ndr->depth++;
21995         if (flags & NDR_SET_VALUES) {
21996                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21997         }
21998         if (flags & NDR_IN) {
21999                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
22000                 ndr->depth++;
22001                 ndr_print_ptr(ndr, "handle", r->in.handle);
22002                 ndr->depth++;
22003                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22004                 ndr->depth--;
22005                 ndr_print_string(ndr, "key_name", r->in.key_name);
22006                 ndr_print_string(ndr, "value_name", r->in.value_name);
22007                 ndr->depth--;
22008         }
22009         if (flags & NDR_OUT) {
22010                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
22011                 ndr->depth++;
22012                 ndr_print_WERROR(ndr, "result", r->out.result);
22013                 ndr->depth--;
22014         }
22015         ndr->depth--;
22016 }
22017
22018 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
22019 {
22020         if (flags & NDR_IN) {
22021                 if (r->in.handle == NULL) {
22022                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22023                 }
22024                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
22028                 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));
22029         }
22030         if (flags & NDR_OUT) {
22031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22032         }
22033         return NDR_ERR_SUCCESS;
22034 }
22035
22036 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
22037 {
22038         TALLOC_CTX *_mem_save_handle_0;
22039         if (flags & NDR_IN) {
22040                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22041                         NDR_PULL_ALLOC(ndr, r->in.handle);
22042                 }
22043                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22044                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22045                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22046                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22047                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
22048                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
22049                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
22050                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
22051                 }
22052                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
22053                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
22054         }
22055         if (flags & NDR_OUT) {
22056                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22057         }
22058         return NDR_ERR_SUCCESS;
22059 }
22060
22061 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
22062 {
22063         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
22064         ndr->depth++;
22065         if (flags & NDR_SET_VALUES) {
22066                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22067         }
22068         if (flags & NDR_IN) {
22069                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
22070                 ndr->depth++;
22071                 ndr_print_ptr(ndr, "handle", r->in.handle);
22072                 ndr->depth++;
22073                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22074                 ndr->depth--;
22075                 ndr_print_string(ndr, "key_name", r->in.key_name);
22076                 ndr->depth--;
22077         }
22078         if (flags & NDR_OUT) {
22079                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
22080                 ndr->depth++;
22081                 ndr_print_WERROR(ndr, "result", r->out.result);
22082                 ndr->depth--;
22083         }
22084         ndr->depth--;
22085 }
22086
22087 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
22088 {
22089         if (flags & NDR_IN) {
22090         }
22091         if (flags & NDR_OUT) {
22092                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22093         }
22094         return NDR_ERR_SUCCESS;
22095 }
22096
22097 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
22098 {
22099         if (flags & NDR_IN) {
22100         }
22101         if (flags & NDR_OUT) {
22102                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22103         }
22104         return NDR_ERR_SUCCESS;
22105 }
22106
22107 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
22108 {
22109         ndr_print_struct(ndr, name, "spoolss_53");
22110         ndr->depth++;
22111         if (flags & NDR_SET_VALUES) {
22112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22113         }
22114         if (flags & NDR_IN) {
22115                 ndr_print_struct(ndr, "in", "spoolss_53");
22116                 ndr->depth++;
22117                 ndr->depth--;
22118         }
22119         if (flags & NDR_OUT) {
22120                 ndr_print_struct(ndr, "out", "spoolss_53");
22121                 ndr->depth++;
22122                 ndr_print_WERROR(ndr, "result", r->out.result);
22123                 ndr->depth--;
22124         }
22125         ndr->depth--;
22126 }
22127
22128 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22129 {
22130         if (flags & NDR_IN) {
22131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22132                 if (r->in.server) {
22133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22136                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22137                 }
22138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22141                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22145                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22146                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
22147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
22148         }
22149         if (flags & NDR_OUT) {
22150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22151         }
22152         return NDR_ERR_SUCCESS;
22153 }
22154
22155 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
22156 {
22157         uint32_t _ptr_server;
22158         TALLOC_CTX *_mem_save_server_0;
22159         if (flags & NDR_IN) {
22160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22161                 if (_ptr_server) {
22162                         NDR_PULL_ALLOC(ndr, r->in.server);
22163                 } else {
22164                         r->in.server = NULL;
22165                 }
22166                 if (r->in.server) {
22167                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22168                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22169                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22170                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22171                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22172                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
22173                         }
22174                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22175                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22177                 }
22178                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22179                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22180                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22181                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
22182                 }
22183                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22184                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22185                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22186                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22187                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22188                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.driver), ndr_get_array_length(ndr, &r->in.driver));
22189                 }
22190                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22191                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22192                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
22193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
22194         }
22195         if (flags & NDR_OUT) {
22196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22197         }
22198         return NDR_ERR_SUCCESS;
22199 }
22200
22201 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
22202 {
22203         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
22204         ndr->depth++;
22205         if (flags & NDR_SET_VALUES) {
22206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22207         }
22208         if (flags & NDR_IN) {
22209                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
22210                 ndr->depth++;
22211                 ndr_print_ptr(ndr, "server", r->in.server);
22212                 ndr->depth++;
22213                 if (r->in.server) {
22214                         ndr_print_string(ndr, "server", r->in.server);
22215                 }
22216                 ndr->depth--;
22217                 ndr_print_string(ndr, "architecture", r->in.architecture);
22218                 ndr_print_string(ndr, "driver", r->in.driver);
22219                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
22220                 ndr_print_uint32(ndr, "version", r->in.version);
22221                 ndr->depth--;
22222         }
22223         if (flags & NDR_OUT) {
22224                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
22225                 ndr->depth++;
22226                 ndr_print_WERROR(ndr, "result", r->out.result);
22227                 ndr->depth--;
22228         }
22229         ndr->depth--;
22230 }
22231
22232 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
22233 {
22234         if (flags & NDR_IN) {
22235         }
22236         if (flags & NDR_OUT) {
22237                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22238         }
22239         return NDR_ERR_SUCCESS;
22240 }
22241
22242 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
22243 {
22244         if (flags & NDR_IN) {
22245         }
22246         if (flags & NDR_OUT) {
22247                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22248         }
22249         return NDR_ERR_SUCCESS;
22250 }
22251
22252 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
22253 {
22254         ndr_print_struct(ndr, name, "spoolss_55");
22255         ndr->depth++;
22256         if (flags & NDR_SET_VALUES) {
22257                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22258         }
22259         if (flags & NDR_IN) {
22260                 ndr_print_struct(ndr, "in", "spoolss_55");
22261                 ndr->depth++;
22262                 ndr->depth--;
22263         }
22264         if (flags & NDR_OUT) {
22265                 ndr_print_struct(ndr, "out", "spoolss_55");
22266                 ndr->depth++;
22267                 ndr_print_WERROR(ndr, "result", r->out.result);
22268                 ndr->depth--;
22269         }
22270         ndr->depth--;
22271 }
22272
22273 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
22274 {
22275         if (flags & NDR_IN) {
22276         }
22277         if (flags & NDR_OUT) {
22278                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22279         }
22280         return NDR_ERR_SUCCESS;
22281 }
22282
22283 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
22284 {
22285         if (flags & NDR_IN) {
22286         }
22287         if (flags & NDR_OUT) {
22288                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22289         }
22290         return NDR_ERR_SUCCESS;
22291 }
22292
22293 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
22294 {
22295         ndr_print_struct(ndr, name, "spoolss_56");
22296         ndr->depth++;
22297         if (flags & NDR_SET_VALUES) {
22298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22299         }
22300         if (flags & NDR_IN) {
22301                 ndr_print_struct(ndr, "in", "spoolss_56");
22302                 ndr->depth++;
22303                 ndr->depth--;
22304         }
22305         if (flags & NDR_OUT) {
22306                 ndr_print_struct(ndr, "out", "spoolss_56");
22307                 ndr->depth++;
22308                 ndr_print_WERROR(ndr, "result", r->out.result);
22309                 ndr->depth--;
22310         }
22311         ndr->depth--;
22312 }
22313
22314 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
22315 {
22316         if (flags & NDR_IN) {
22317         }
22318         if (flags & NDR_OUT) {
22319                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22320         }
22321         return NDR_ERR_SUCCESS;
22322 }
22323
22324 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
22325 {
22326         if (flags & NDR_IN) {
22327         }
22328         if (flags & NDR_OUT) {
22329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22330         }
22331         return NDR_ERR_SUCCESS;
22332 }
22333
22334 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
22335 {
22336         ndr_print_struct(ndr, name, "spoolss_57");
22337         ndr->depth++;
22338         if (flags & NDR_SET_VALUES) {
22339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22340         }
22341         if (flags & NDR_IN) {
22342                 ndr_print_struct(ndr, "in", "spoolss_57");
22343                 ndr->depth++;
22344                 ndr->depth--;
22345         }
22346         if (flags & NDR_OUT) {
22347                 ndr_print_struct(ndr, "out", "spoolss_57");
22348                 ndr->depth++;
22349                 ndr_print_WERROR(ndr, "result", r->out.result);
22350                 ndr->depth--;
22351         }
22352         ndr->depth--;
22353 }
22354
22355 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
22356 {
22357         if (flags & NDR_IN) {
22358                 if (r->in.handle == NULL) {
22359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22360                 }
22361                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
22365                 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));
22366                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
22367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
22368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22369                 if (r->in.status_code == NULL) {
22370                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22371                 }
22372                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
22373         }
22374         if (flags & NDR_OUT) {
22375                 if (r->out.out_data == NULL) {
22376                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22377                 }
22378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
22379                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
22380                 if (r->out.needed == NULL) {
22381                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22382                 }
22383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22384                 if (r->out.status_code == NULL) {
22385                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22386                 }
22387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
22388                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22389         }
22390         return NDR_ERR_SUCCESS;
22391 }
22392
22393 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
22394 {
22395         TALLOC_CTX *_mem_save_handle_0;
22396         TALLOC_CTX *_mem_save_needed_0;
22397         TALLOC_CTX *_mem_save_status_code_0;
22398         if (flags & NDR_IN) {
22399                 ZERO_STRUCT(r->out);
22400
22401                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22402                         NDR_PULL_ALLOC(ndr, r->in.handle);
22403                 }
22404                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22405                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22406                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22407                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22408                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
22409                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
22410                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
22411                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.function_name), ndr_get_array_length(ndr, &r->in.function_name));
22412                 }
22413                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
22414                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.function_name, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t), CH_UTF16));
22415                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
22416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
22417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
22418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22419                         NDR_PULL_ALLOC(ndr, r->in.status_code);
22420                 }
22421                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22422                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
22423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
22424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22425                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
22426                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
22427                 NDR_PULL_ALLOC(ndr, r->out.needed);
22428                 ZERO_STRUCTP(r->out.needed);
22429                 NDR_PULL_ALLOC(ndr, r->out.status_code);
22430                 *r->out.status_code = *r->in.status_code;
22431         }
22432         if (flags & NDR_OUT) {
22433                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
22434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22435                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
22436                 }
22437                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
22438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22439                         NDR_PULL_ALLOC(ndr, r->out.needed);
22440                 }
22441                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22442                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22446                         NDR_PULL_ALLOC(ndr, r->out.status_code);
22447                 }
22448                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
22449                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
22450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
22451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
22452                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22453                 if (r->out.out_data) {
22454                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
22455                 }
22456         }
22457         return NDR_ERR_SUCCESS;
22458 }
22459
22460 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
22461 {
22462         ndr_print_struct(ndr, name, "spoolss_XcvData");
22463         ndr->depth++;
22464         if (flags & NDR_SET_VALUES) {
22465                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22466         }
22467         if (flags & NDR_IN) {
22468                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
22469                 ndr->depth++;
22470                 ndr_print_ptr(ndr, "handle", r->in.handle);
22471                 ndr->depth++;
22472                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22473                 ndr->depth--;
22474                 ndr_print_string(ndr, "function_name", r->in.function_name);
22475                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
22476                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
22477                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
22478                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
22479                 ndr->depth++;
22480                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
22481                 ndr->depth--;
22482                 ndr->depth--;
22483         }
22484         if (flags & NDR_OUT) {
22485                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
22486                 ndr->depth++;
22487                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
22488                 ndr->depth++;
22489                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
22490                 ndr->depth--;
22491                 ndr_print_ptr(ndr, "needed", r->out.needed);
22492                 ndr->depth++;
22493                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22494                 ndr->depth--;
22495                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
22496                 ndr->depth++;
22497                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
22498                 ndr->depth--;
22499                 ndr_print_WERROR(ndr, "result", r->out.result);
22500                 ndr->depth--;
22501         }
22502         ndr->depth--;
22503 }
22504
22505 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
22506 {
22507         if (flags & NDR_IN) {
22508                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22509                 if (r->in.servername) {
22510                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22512                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22513                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22514                 }
22515                 if (r->in.info_ctr == NULL) {
22516                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22517                 }
22518                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22519                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
22520         }
22521         if (flags & NDR_OUT) {
22522                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22523         }
22524         return NDR_ERR_SUCCESS;
22525 }
22526
22527 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
22528 {
22529         uint32_t _ptr_servername;
22530         TALLOC_CTX *_mem_save_servername_0;
22531         TALLOC_CTX *_mem_save_info_ctr_0;
22532         if (flags & NDR_IN) {
22533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22534                 if (_ptr_servername) {
22535                         NDR_PULL_ALLOC(ndr, r->in.servername);
22536                 } else {
22537                         r->in.servername = NULL;
22538                 }
22539                 if (r->in.servername) {
22540                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22541                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22542                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22543                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22544                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22545                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
22546                         }
22547                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22548                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22550                 }
22551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22552                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
22553                 }
22554                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
22555                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
22556                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
22558                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
22559         }
22560         if (flags & NDR_OUT) {
22561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22562         }
22563         return NDR_ERR_SUCCESS;
22564 }
22565
22566 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
22567 {
22568         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
22569         ndr->depth++;
22570         if (flags & NDR_SET_VALUES) {
22571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22572         }
22573         if (flags & NDR_IN) {
22574                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
22575                 ndr->depth++;
22576                 ndr_print_ptr(ndr, "servername", r->in.servername);
22577                 ndr->depth++;
22578                 if (r->in.servername) {
22579                         ndr_print_string(ndr, "servername", r->in.servername);
22580                 }
22581                 ndr->depth--;
22582                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
22583                 ndr->depth++;
22584                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
22585                 ndr->depth--;
22586                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
22587                 ndr->depth--;
22588         }
22589         if (flags & NDR_OUT) {
22590                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
22591                 ndr->depth++;
22592                 ndr_print_WERROR(ndr, "result", r->out.result);
22593                 ndr->depth--;
22594         }
22595         ndr->depth--;
22596 }
22597
22598 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
22599 {
22600         if (flags & NDR_IN) {
22601         }
22602         if (flags & NDR_OUT) {
22603                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22604         }
22605         return NDR_ERR_SUCCESS;
22606 }
22607
22608 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
22609 {
22610         if (flags & NDR_IN) {
22611         }
22612         if (flags & NDR_OUT) {
22613                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22614         }
22615         return NDR_ERR_SUCCESS;
22616 }
22617
22618 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
22619 {
22620         ndr_print_struct(ndr, name, "spoolss_5a");
22621         ndr->depth++;
22622         if (flags & NDR_SET_VALUES) {
22623                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22624         }
22625         if (flags & NDR_IN) {
22626                 ndr_print_struct(ndr, "in", "spoolss_5a");
22627                 ndr->depth++;
22628                 ndr->depth--;
22629         }
22630         if (flags & NDR_OUT) {
22631                 ndr_print_struct(ndr, "out", "spoolss_5a");
22632                 ndr->depth++;
22633                 ndr_print_WERROR(ndr, "result", r->out.result);
22634                 ndr->depth--;
22635         }
22636         ndr->depth--;
22637 }
22638
22639 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
22640 {
22641         if (flags & NDR_IN) {
22642         }
22643         if (flags & NDR_OUT) {
22644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22645         }
22646         return NDR_ERR_SUCCESS;
22647 }
22648
22649 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
22650 {
22651         if (flags & NDR_IN) {
22652         }
22653         if (flags & NDR_OUT) {
22654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22655         }
22656         return NDR_ERR_SUCCESS;
22657 }
22658
22659 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
22660 {
22661         ndr_print_struct(ndr, name, "spoolss_5b");
22662         ndr->depth++;
22663         if (flags & NDR_SET_VALUES) {
22664                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22665         }
22666         if (flags & NDR_IN) {
22667                 ndr_print_struct(ndr, "in", "spoolss_5b");
22668                 ndr->depth++;
22669                 ndr->depth--;
22670         }
22671         if (flags & NDR_OUT) {
22672                 ndr_print_struct(ndr, "out", "spoolss_5b");
22673                 ndr->depth++;
22674                 ndr_print_WERROR(ndr, "result", r->out.result);
22675                 ndr->depth--;
22676         }
22677         ndr->depth--;
22678 }
22679
22680 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
22681 {
22682         if (flags & NDR_IN) {
22683         }
22684         if (flags & NDR_OUT) {
22685                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22686         }
22687         return NDR_ERR_SUCCESS;
22688 }
22689
22690 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
22691 {
22692         if (flags & NDR_IN) {
22693         }
22694         if (flags & NDR_OUT) {
22695                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22696         }
22697         return NDR_ERR_SUCCESS;
22698 }
22699
22700 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
22701 {
22702         ndr_print_struct(ndr, name, "spoolss_5c");
22703         ndr->depth++;
22704         if (flags & NDR_SET_VALUES) {
22705                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22706         }
22707         if (flags & NDR_IN) {
22708                 ndr_print_struct(ndr, "in", "spoolss_5c");
22709                 ndr->depth++;
22710                 ndr->depth--;
22711         }
22712         if (flags & NDR_OUT) {
22713                 ndr_print_struct(ndr, "out", "spoolss_5c");
22714                 ndr->depth++;
22715                 ndr_print_WERROR(ndr, "result", r->out.result);
22716                 ndr->depth--;
22717         }
22718         ndr->depth--;
22719 }
22720
22721 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
22722 {
22723         if (flags & NDR_IN) {
22724         }
22725         if (flags & NDR_OUT) {
22726                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22727         }
22728         return NDR_ERR_SUCCESS;
22729 }
22730
22731 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
22732 {
22733         if (flags & NDR_IN) {
22734         }
22735         if (flags & NDR_OUT) {
22736                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22737         }
22738         return NDR_ERR_SUCCESS;
22739 }
22740
22741 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
22742 {
22743         ndr_print_struct(ndr, name, "spoolss_5d");
22744         ndr->depth++;
22745         if (flags & NDR_SET_VALUES) {
22746                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22747         }
22748         if (flags & NDR_IN) {
22749                 ndr_print_struct(ndr, "in", "spoolss_5d");
22750                 ndr->depth++;
22751                 ndr->depth--;
22752         }
22753         if (flags & NDR_OUT) {
22754                 ndr_print_struct(ndr, "out", "spoolss_5d");
22755                 ndr->depth++;
22756                 ndr_print_WERROR(ndr, "result", r->out.result);
22757                 ndr->depth--;
22758         }
22759         ndr->depth--;
22760 }
22761
22762 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
22763 {
22764         if (flags & NDR_IN) {
22765         }
22766         if (flags & NDR_OUT) {
22767                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22768         }
22769         return NDR_ERR_SUCCESS;
22770 }
22771
22772 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
22773 {
22774         if (flags & NDR_IN) {
22775         }
22776         if (flags & NDR_OUT) {
22777                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22778         }
22779         return NDR_ERR_SUCCESS;
22780 }
22781
22782 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
22783 {
22784         ndr_print_struct(ndr, name, "spoolss_5e");
22785         ndr->depth++;
22786         if (flags & NDR_SET_VALUES) {
22787                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22788         }
22789         if (flags & NDR_IN) {
22790                 ndr_print_struct(ndr, "in", "spoolss_5e");
22791                 ndr->depth++;
22792                 ndr->depth--;
22793         }
22794         if (flags & NDR_OUT) {
22795                 ndr_print_struct(ndr, "out", "spoolss_5e");
22796                 ndr->depth++;
22797                 ndr_print_WERROR(ndr, "result", r->out.result);
22798                 ndr->depth--;
22799         }
22800         ndr->depth--;
22801 }
22802
22803 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
22804 {
22805         if (flags & NDR_IN) {
22806         }
22807         if (flags & NDR_OUT) {
22808                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22809         }
22810         return NDR_ERR_SUCCESS;
22811 }
22812
22813 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
22814 {
22815         if (flags & NDR_IN) {
22816         }
22817         if (flags & NDR_OUT) {
22818                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22819         }
22820         return NDR_ERR_SUCCESS;
22821 }
22822
22823 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
22824 {
22825         ndr_print_struct(ndr, name, "spoolss_5f");
22826         ndr->depth++;
22827         if (flags & NDR_SET_VALUES) {
22828                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22829         }
22830         if (flags & NDR_IN) {
22831                 ndr_print_struct(ndr, "in", "spoolss_5f");
22832                 ndr->depth++;
22833                 ndr->depth--;
22834         }
22835         if (flags & NDR_OUT) {
22836                 ndr_print_struct(ndr, "out", "spoolss_5f");
22837                 ndr->depth++;
22838                 ndr_print_WERROR(ndr, "result", r->out.result);
22839                 ndr->depth--;
22840         }
22841         ndr->depth--;
22842 }
22843
22844 static const struct ndr_interface_call spoolss_calls[] = {
22845         {
22846                 "spoolss_EnumPrinters",
22847                 sizeof(struct spoolss_EnumPrinters),
22848                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
22849                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
22850                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
22851                 false,
22852         },
22853         {
22854                 "spoolss_OpenPrinter",
22855                 sizeof(struct spoolss_OpenPrinter),
22856                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
22857                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
22858                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
22859                 false,
22860         },
22861         {
22862                 "spoolss_SetJob",
22863                 sizeof(struct spoolss_SetJob),
22864                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
22865                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
22866                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
22867                 false,
22868         },
22869         {
22870                 "spoolss_GetJob",
22871                 sizeof(struct spoolss_GetJob),
22872                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
22873                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
22874                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
22875                 false,
22876         },
22877         {
22878                 "spoolss_EnumJobs",
22879                 sizeof(struct spoolss_EnumJobs),
22880                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
22881                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
22882                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
22883                 false,
22884         },
22885         {
22886                 "spoolss_AddPrinter",
22887                 sizeof(struct spoolss_AddPrinter),
22888                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
22889                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
22890                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
22891                 false,
22892         },
22893         {
22894                 "spoolss_DeletePrinter",
22895                 sizeof(struct spoolss_DeletePrinter),
22896                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
22897                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
22898                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
22899                 false,
22900         },
22901         {
22902                 "spoolss_SetPrinter",
22903                 sizeof(struct spoolss_SetPrinter),
22904                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
22905                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
22906                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
22907                 false,
22908         },
22909         {
22910                 "spoolss_GetPrinter",
22911                 sizeof(struct spoolss_GetPrinter),
22912                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
22913                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
22914                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
22915                 false,
22916         },
22917         {
22918                 "spoolss_AddPrinterDriver",
22919                 sizeof(struct spoolss_AddPrinterDriver),
22920                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
22921                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
22922                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
22923                 false,
22924         },
22925         {
22926                 "spoolss_EnumPrinterDrivers",
22927                 sizeof(struct spoolss_EnumPrinterDrivers),
22928                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
22929                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
22930                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
22931                 false,
22932         },
22933         {
22934                 "spoolss_GetPrinterDriver",
22935                 sizeof(struct spoolss_GetPrinterDriver),
22936                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
22937                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
22938                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
22939                 false,
22940         },
22941         {
22942                 "spoolss_GetPrinterDriverDirectory",
22943                 sizeof(struct spoolss_GetPrinterDriverDirectory),
22944                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
22945                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
22946                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
22947                 false,
22948         },
22949         {
22950                 "spoolss_DeletePrinterDriver",
22951                 sizeof(struct spoolss_DeletePrinterDriver),
22952                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
22953                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
22954                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
22955                 false,
22956         },
22957         {
22958                 "spoolss_AddPrintProcessor",
22959                 sizeof(struct spoolss_AddPrintProcessor),
22960                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
22961                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
22962                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
22963                 false,
22964         },
22965         {
22966                 "spoolss_EnumPrintProcessors",
22967                 sizeof(struct spoolss_EnumPrintProcessors),
22968                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
22969                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
22970                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
22971                 false,
22972         },
22973         {
22974                 "spoolss_GetPrintProcessorDirectory",
22975                 sizeof(struct spoolss_GetPrintProcessorDirectory),
22976                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
22977                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
22978                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
22979                 false,
22980         },
22981         {
22982                 "spoolss_StartDocPrinter",
22983                 sizeof(struct spoolss_StartDocPrinter),
22984                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
22985                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
22986                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
22987                 false,
22988         },
22989         {
22990                 "spoolss_StartPagePrinter",
22991                 sizeof(struct spoolss_StartPagePrinter),
22992                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
22993                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
22994                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
22995                 false,
22996         },
22997         {
22998                 "spoolss_WritePrinter",
22999                 sizeof(struct spoolss_WritePrinter),
23000                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
23001                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
23002                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
23003                 false,
23004         },
23005         {
23006                 "spoolss_EndPagePrinter",
23007                 sizeof(struct spoolss_EndPagePrinter),
23008                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
23009                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
23010                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
23011                 false,
23012         },
23013         {
23014                 "spoolss_AbortPrinter",
23015                 sizeof(struct spoolss_AbortPrinter),
23016                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
23017                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
23018                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
23019                 false,
23020         },
23021         {
23022                 "spoolss_ReadPrinter",
23023                 sizeof(struct spoolss_ReadPrinter),
23024                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
23025                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
23026                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
23027                 false,
23028         },
23029         {
23030                 "spoolss_EndDocPrinter",
23031                 sizeof(struct spoolss_EndDocPrinter),
23032                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
23033                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
23034                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
23035                 false,
23036         },
23037         {
23038                 "spoolss_AddJob",
23039                 sizeof(struct spoolss_AddJob),
23040                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
23041                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
23042                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
23043                 false,
23044         },
23045         {
23046                 "spoolss_ScheduleJob",
23047                 sizeof(struct spoolss_ScheduleJob),
23048                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
23049                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
23050                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
23051                 false,
23052         },
23053         {
23054                 "spoolss_GetPrinterData",
23055                 sizeof(struct spoolss_GetPrinterData),
23056                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
23057                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
23058                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
23059                 false,
23060         },
23061         {
23062                 "spoolss_SetPrinterData",
23063                 sizeof(struct spoolss_SetPrinterData),
23064                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
23065                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
23066                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
23067                 false,
23068         },
23069         {
23070                 "spoolss_WaitForPrinterChange",
23071                 sizeof(struct spoolss_WaitForPrinterChange),
23072                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
23073                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
23074                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
23075                 false,
23076         },
23077         {
23078                 "spoolss_ClosePrinter",
23079                 sizeof(struct spoolss_ClosePrinter),
23080                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
23081                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
23082                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
23083                 false,
23084         },
23085         {
23086                 "spoolss_AddForm",
23087                 sizeof(struct spoolss_AddForm),
23088                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
23089                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
23090                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
23091                 false,
23092         },
23093         {
23094                 "spoolss_DeleteForm",
23095                 sizeof(struct spoolss_DeleteForm),
23096                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
23097                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
23098                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
23099                 false,
23100         },
23101         {
23102                 "spoolss_GetForm",
23103                 sizeof(struct spoolss_GetForm),
23104                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
23105                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
23106                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
23107                 false,
23108         },
23109         {
23110                 "spoolss_SetForm",
23111                 sizeof(struct spoolss_SetForm),
23112                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
23113                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
23114                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
23115                 false,
23116         },
23117         {
23118                 "spoolss_EnumForms",
23119                 sizeof(struct spoolss_EnumForms),
23120                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
23121                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
23122                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
23123                 false,
23124         },
23125         {
23126                 "spoolss_EnumPorts",
23127                 sizeof(struct spoolss_EnumPorts),
23128                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
23129                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
23130                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
23131                 false,
23132         },
23133         {
23134                 "spoolss_EnumMonitors",
23135                 sizeof(struct spoolss_EnumMonitors),
23136                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
23137                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
23138                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
23139                 false,
23140         },
23141         {
23142                 "spoolss_AddPort",
23143                 sizeof(struct spoolss_AddPort),
23144                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
23145                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
23146                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
23147                 false,
23148         },
23149         {
23150                 "spoolss_ConfigurePort",
23151                 sizeof(struct spoolss_ConfigurePort),
23152                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
23153                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
23154                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
23155                 false,
23156         },
23157         {
23158                 "spoolss_DeletePort",
23159                 sizeof(struct spoolss_DeletePort),
23160                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
23161                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
23162                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
23163                 false,
23164         },
23165         {
23166                 "spoolss_CreatePrinterIC",
23167                 sizeof(struct spoolss_CreatePrinterIC),
23168                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
23169                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
23170                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
23171                 false,
23172         },
23173         {
23174                 "spoolss_PlayGDIScriptOnPrinterIC",
23175                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
23176                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
23177                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
23178                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
23179                 false,
23180         },
23181         {
23182                 "spoolss_DeletePrinterIC",
23183                 sizeof(struct spoolss_DeletePrinterIC),
23184                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
23185                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
23186                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
23187                 false,
23188         },
23189         {
23190                 "spoolss_AddPrinterConnection",
23191                 sizeof(struct spoolss_AddPrinterConnection),
23192                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
23193                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
23194                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
23195                 false,
23196         },
23197         {
23198                 "spoolss_DeletePrinterConnection",
23199                 sizeof(struct spoolss_DeletePrinterConnection),
23200                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
23201                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
23202                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
23203                 false,
23204         },
23205         {
23206                 "spoolss_PrinterMessageBox",
23207                 sizeof(struct spoolss_PrinterMessageBox),
23208                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
23209                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
23210                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
23211                 false,
23212         },
23213         {
23214                 "spoolss_AddMonitor",
23215                 sizeof(struct spoolss_AddMonitor),
23216                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
23217                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
23218                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
23219                 false,
23220         },
23221         {
23222                 "spoolss_DeleteMonitor",
23223                 sizeof(struct spoolss_DeleteMonitor),
23224                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
23225                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
23226                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
23227                 false,
23228         },
23229         {
23230                 "spoolss_DeletePrintProcessor",
23231                 sizeof(struct spoolss_DeletePrintProcessor),
23232                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
23233                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
23234                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
23235                 false,
23236         },
23237         {
23238                 "spoolss_AddPrintProvidor",
23239                 sizeof(struct spoolss_AddPrintProvidor),
23240                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
23241                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
23242                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
23243                 false,
23244         },
23245         {
23246                 "spoolss_DeletePrintProvidor",
23247                 sizeof(struct spoolss_DeletePrintProvidor),
23248                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
23249                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
23250                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
23251                 false,
23252         },
23253         {
23254                 "spoolss_EnumPrintProcDataTypes",
23255                 sizeof(struct spoolss_EnumPrintProcDataTypes),
23256                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
23257                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
23258                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
23259                 false,
23260         },
23261         {
23262                 "spoolss_ResetPrinter",
23263                 sizeof(struct spoolss_ResetPrinter),
23264                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
23265                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
23266                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
23267                 false,
23268         },
23269         {
23270                 "spoolss_GetPrinterDriver2",
23271                 sizeof(struct spoolss_GetPrinterDriver2),
23272                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
23273                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
23274                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
23275                 false,
23276         },
23277         {
23278                 "spoolss_FindFirstPrinterChangeNotification",
23279                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
23280                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
23281                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
23282                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
23283                 false,
23284         },
23285         {
23286                 "spoolss_FindNextPrinterChangeNotification",
23287                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
23288                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
23289                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
23290                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
23291                 false,
23292         },
23293         {
23294                 "spoolss_FindClosePrinterNotify",
23295                 sizeof(struct spoolss_FindClosePrinterNotify),
23296                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
23297                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
23298                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
23299                 false,
23300         },
23301         {
23302                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
23303                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
23304                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23305                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23306                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
23307                 false,
23308         },
23309         {
23310                 "spoolss_ReplyOpenPrinter",
23311                 sizeof(struct spoolss_ReplyOpenPrinter),
23312                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
23313                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
23314                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
23315                 false,
23316         },
23317         {
23318                 "spoolss_RouterReplyPrinter",
23319                 sizeof(struct spoolss_RouterReplyPrinter),
23320                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
23321                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
23322                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
23323                 false,
23324         },
23325         {
23326                 "spoolss_ReplyClosePrinter",
23327                 sizeof(struct spoolss_ReplyClosePrinter),
23328                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
23329                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
23330                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
23331                 false,
23332         },
23333         {
23334                 "spoolss_AddPortEx",
23335                 sizeof(struct spoolss_AddPortEx),
23336                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
23337                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
23338                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
23339                 false,
23340         },
23341         {
23342                 "spoolss_RouterFindFirstPrinterChangeNotification",
23343                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
23344                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
23345                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
23346                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
23347                 false,
23348         },
23349         {
23350                 "spoolss_SpoolerInit",
23351                 sizeof(struct spoolss_SpoolerInit),
23352                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
23353                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
23354                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
23355                 false,
23356         },
23357         {
23358                 "spoolss_ResetPrinterEx",
23359                 sizeof(struct spoolss_ResetPrinterEx),
23360                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
23361                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
23362                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
23363                 false,
23364         },
23365         {
23366                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
23367                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
23368                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23369                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23370                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
23371                 false,
23372         },
23373         {
23374                 "spoolss_RouterReplyPrinterEx",
23375                 sizeof(struct spoolss_RouterReplyPrinterEx),
23376                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
23377                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
23378                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
23379                 false,
23380         },
23381         {
23382                 "spoolss_RouterRefreshPrinterChangeNotify",
23383                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
23384                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
23385                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
23386                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
23387                 false,
23388         },
23389         {
23390                 "spoolss_44",
23391                 sizeof(struct spoolss_44),
23392                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
23393                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
23394                 (ndr_print_function_t) ndr_print_spoolss_44,
23395                 false,
23396         },
23397         {
23398                 "spoolss_OpenPrinterEx",
23399                 sizeof(struct spoolss_OpenPrinterEx),
23400                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
23401                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
23402                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
23403                 false,
23404         },
23405         {
23406                 "spoolss_AddPrinterEx",
23407                 sizeof(struct spoolss_AddPrinterEx),
23408                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
23409                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
23410                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
23411                 false,
23412         },
23413         {
23414                 "spoolss_47",
23415                 sizeof(struct spoolss_47),
23416                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
23417                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
23418                 (ndr_print_function_t) ndr_print_spoolss_47,
23419                 false,
23420         },
23421         {
23422                 "spoolss_EnumPrinterData",
23423                 sizeof(struct spoolss_EnumPrinterData),
23424                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
23425                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
23426                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
23427                 false,
23428         },
23429         {
23430                 "spoolss_DeletePrinterData",
23431                 sizeof(struct spoolss_DeletePrinterData),
23432                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
23433                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
23434                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
23435                 false,
23436         },
23437         {
23438                 "spoolss_4a",
23439                 sizeof(struct spoolss_4a),
23440                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
23441                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
23442                 (ndr_print_function_t) ndr_print_spoolss_4a,
23443                 false,
23444         },
23445         {
23446                 "spoolss_4b",
23447                 sizeof(struct spoolss_4b),
23448                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
23449                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
23450                 (ndr_print_function_t) ndr_print_spoolss_4b,
23451                 false,
23452         },
23453         {
23454                 "spoolss_4c",
23455                 sizeof(struct spoolss_4c),
23456                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
23457                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
23458                 (ndr_print_function_t) ndr_print_spoolss_4c,
23459                 false,
23460         },
23461         {
23462                 "spoolss_SetPrinterDataEx",
23463                 sizeof(struct spoolss_SetPrinterDataEx),
23464                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
23465                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
23466                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
23467                 false,
23468         },
23469         {
23470                 "spoolss_GetPrinterDataEx",
23471                 sizeof(struct spoolss_GetPrinterDataEx),
23472                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
23473                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
23474                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
23475                 false,
23476         },
23477         {
23478                 "spoolss_EnumPrinterDataEx",
23479                 sizeof(struct spoolss_EnumPrinterDataEx),
23480                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
23481                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
23482                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
23483                 false,
23484         },
23485         {
23486                 "spoolss_EnumPrinterKey",
23487                 sizeof(struct spoolss_EnumPrinterKey),
23488                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
23489                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
23490                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
23491                 false,
23492         },
23493         {
23494                 "spoolss_DeletePrinterDataEx",
23495                 sizeof(struct spoolss_DeletePrinterDataEx),
23496                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
23497                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
23498                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
23499                 false,
23500         },
23501         {
23502                 "spoolss_DeletePrinterKey",
23503                 sizeof(struct spoolss_DeletePrinterKey),
23504                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
23505                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
23506                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
23507                 false,
23508         },
23509         {
23510                 "spoolss_53",
23511                 sizeof(struct spoolss_53),
23512                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
23513                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
23514                 (ndr_print_function_t) ndr_print_spoolss_53,
23515                 false,
23516         },
23517         {
23518                 "spoolss_DeletePrinterDriverEx",
23519                 sizeof(struct spoolss_DeletePrinterDriverEx),
23520                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
23521                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
23522                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
23523                 false,
23524         },
23525         {
23526                 "spoolss_55",
23527                 sizeof(struct spoolss_55),
23528                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
23529                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
23530                 (ndr_print_function_t) ndr_print_spoolss_55,
23531                 false,
23532         },
23533         {
23534                 "spoolss_56",
23535                 sizeof(struct spoolss_56),
23536                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
23537                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
23538                 (ndr_print_function_t) ndr_print_spoolss_56,
23539                 false,
23540         },
23541         {
23542                 "spoolss_57",
23543                 sizeof(struct spoolss_57),
23544                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
23545                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
23546                 (ndr_print_function_t) ndr_print_spoolss_57,
23547                 false,
23548         },
23549         {
23550                 "spoolss_XcvData",
23551                 sizeof(struct spoolss_XcvData),
23552                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
23553                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
23554                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
23555                 false,
23556         },
23557         {
23558                 "spoolss_AddPrinterDriverEx",
23559                 sizeof(struct spoolss_AddPrinterDriverEx),
23560                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
23561                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
23562                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
23563                 false,
23564         },
23565         {
23566                 "spoolss_5a",
23567                 sizeof(struct spoolss_5a),
23568                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
23569                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
23570                 (ndr_print_function_t) ndr_print_spoolss_5a,
23571                 false,
23572         },
23573         {
23574                 "spoolss_5b",
23575                 sizeof(struct spoolss_5b),
23576                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
23577                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
23578                 (ndr_print_function_t) ndr_print_spoolss_5b,
23579                 false,
23580         },
23581         {
23582                 "spoolss_5c",
23583                 sizeof(struct spoolss_5c),
23584                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
23585                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
23586                 (ndr_print_function_t) ndr_print_spoolss_5c,
23587                 false,
23588         },
23589         {
23590                 "spoolss_5d",
23591                 sizeof(struct spoolss_5d),
23592                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
23593                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
23594                 (ndr_print_function_t) ndr_print_spoolss_5d,
23595                 false,
23596         },
23597         {
23598                 "spoolss_5e",
23599                 sizeof(struct spoolss_5e),
23600                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
23601                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
23602                 (ndr_print_function_t) ndr_print_spoolss_5e,
23603                 false,
23604         },
23605         {
23606                 "spoolss_5f",
23607                 sizeof(struct spoolss_5f),
23608                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
23609                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
23610                 (ndr_print_function_t) ndr_print_spoolss_5f,
23611                 false,
23612         },
23613         { NULL, 0, NULL, NULL, NULL, false }
23614 };
23615
23616 static const char * const spoolss_endpoint_strings[] = {
23617         "ncacn_np:[\\pipe\\spoolss]",
23618 };
23619
23620 static const struct ndr_interface_string_array spoolss_endpoints = {
23621         .count  = 1,
23622         .names  = spoolss_endpoint_strings
23623 };
23624
23625 static const char * const spoolss_authservice_strings[] = {
23626         "host",
23627 };
23628
23629 static const struct ndr_interface_string_array spoolss_authservices = {
23630         .count  = 1,
23631         .names  = spoolss_authservice_strings
23632 };
23633
23634
23635 const struct ndr_interface_table ndr_table_spoolss = {
23636         .name           = "spoolss",
23637         .syntax_id      = {
23638                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
23639                 NDR_SPOOLSS_VERSION
23640         },
23641         .helpstring     = NDR_SPOOLSS_HELPSTRING,
23642         .num_calls      = 114,
23643         .calls          = spoolss_calls,
23644         .endpoints      = &spoolss_endpoints,
23645         .authservices   = &spoolss_authservices
23646 };
23647